def update_tinydb(self, tinyrundb_json, run_json, rerunWhat): db = TinyDB(tinyrundb_json, sort_keys=True, indent=4, separators=(',', ': ')) db.drop_table('_default') query = Query() runcases = json.loads(open(run_json).read()) for case in runcases: if case['feature'] in db.tables(): feature_table = db.table(case['feature']) if (rerunWhat is not None) and (len(feature_table.search(query.status == rerunWhat)) > 0): feature_table.update({'status': 'rerun'}) else: feature_table = db.table(case['feature']) feature_table.insert(case) db.close()
class ScheduleDB: def __init__(self, location=os.path.join(DEFAULT_LOCATION, DB_FILE_NAME)): self.location = location self.db = TinyDB(self.location) self.vm_table = self.db.table('vms') self.dbsys_table = self.db.table('db') self.cid_table = self.db.table('compartments') self.cron_table = self.db.table('cron') #Query self.query = Query() def flush(self): return self.db.drop_table('vms') and self.db.drop_table('db')
class TinyDBDriver: def __init__(self): self.db = TinyDB('covid.json') self.table_1 = "testing_stats_1" self.table_2 = "testing_stats_2" self.primary_table = None self.secondary_table = None def get_db(self): return self.db def determine_table_names(self): tables = self.db.tables() print(">>>>>>>>>>>") print(tables) print(">>>>>>>>>>>") response = {} if self.table_2 in tables: self.primary_table = self.table_2 self.secondary_table = self.table_1 else: self.primary_table = self.table_1 self.secondary_table = self.table_2 def get_primary_table(self): return self.primary_table def write_to_tinydb(self, payloads): self.determine_table_names() print("Before writing records :: Primary table = " + self.primary_table + ", Secondary table = " + self.secondary_table) print("Creating new table => " + self.secondary_table) table = self.db.table(self.secondary_table) table.insert_multiple(payloads) print("Inserted " + str(len(payloads)) + " records into " + self.secondary_table) self.db.drop_table(self.primary_table) print("Dropped older table =>" + self.primary_table) temp_table = self.secondary_table self.secondary_table = self.primary_table self.primary_table = temp_table print("After writing records :: Primary table = " + self.primary_table + ", Secondary table = " + self.secondary_table) return {"table": self.primary_table, "count": len(table.all())}
def init_db(db_file, table): ''' Routine to initialize database file handling a corrupted db by deleting the file and re-initializing. :param db_file: database file :param table: table name :return: database table object ''' db = TinyDB(db_file) dbt = db.table(table) try: db.drop_table(table) except json.decoder.JSONDecodeError: logging.info('{} database corrupted, deleting.'.format(db_file)) os.remove(db_file) db = TinyDB(db_file) dbt = db.table(table) return dbt return dbt
class TinyDBDatabase(metaclass=TinyDBDatabaseMeta): database: TinyDB = None def __init__(self, json_file: str) -> None: self.database = TinyDB(json_file) self.database.insert({"please": "Just work."}) def add_user(self, guild: str, author_id: str): table = self.database.table(guild) table.insert({ 'author': author_id, 'nick': '', 'k': 0, 'j': 0, 'p': 0, 'ch': 0, 'g': 0, 'sz': 0, 'xd': 0 }) def set_user_nick(self, guild: str, author_id: str, author_nick: str): table = self.database.table(guild) table.update({'nick': author_nick}, where('author') == author_id) def add_stats_to_user(self, guild: str, author_id: str, k: int, j: int, p: int, ch: int, g: int, sz: int, xd: int): table = self.database.table(guild) table.update_multiple([(add('k', k), where('author') == author_id), (add('j', j), where('author') == author_id), (add('p', p), where('author') == author_id), (add('ch', ch), where('author') == author_id), (add('g', g), where('author') == author_id), (add('sz', sz), where('author') == author_id), (add('xd', xd), where('author') == author_id)]) def drop_server_table(self, guild: str): self.database.drop_table(guild)
def generate_reports(self, dbfile): ''' ''' # get run duration t1 = self.runtime_stamp t2 = self.end_time stime = datetime( int(t1[:4]), int(t1[4:6]), int(t1[6:8]), int(t1[9:11]), int(t1[11:13]), int(t1[13:15])) etime = datetime( int(t2[:4]), int(t2[4:6]), int(t2[6:8]), int(t2[9:11]), int(t2[11:13]), int(t2[13:15])) run_duration = str(etime - stime) print('Run Duration: {}'.format(run_duration)) # generate cucumber report json file db = TinyDB(dbfile, sort_keys=True, indent=4, separators=(',', ': ')) db.drop_table('_default') query = Query() cucumber_report_json = [] for table in db.tables(): group = db.table(table) reportList = group.search(query.status != 'crashed') feature_report = None for case in reportList: if os.path.exists(case['result_json']): # process new result element = json.loads(open(case['result_json']).read())[0] os.rename(case['result_json'], case['result_json'] + '.processed') elif os.path.exists(case['result_json'] + '.processed'): # process existing result element = json.loads(open(case['result_json'] + '.processed').read())[0] else: group.update({'status': 'crashed'}, doc_ids=[case.doc_id]) if not feature_report: feature_report = element else: feature_report['elements'].append(element['elements'][0])
def test_drop_table(): db = TinyDB(storage=MemoryStorage) default_table_name = db.table(db.default_table_name).name assert [] == list(db.tables()) db.drop_table(default_table_name) db.insert({'a': 1}) assert [default_table_name] == list(db.tables()) db.drop_table(default_table_name) assert [] == list(db.tables()) table_name = 'some-other-table' db = TinyDB(storage=MemoryStorage) db.table(table_name).insert({'a': 1}) assert {table_name} == db.tables() db.drop_table(table_name) assert set() == db.tables() assert table_name not in db._tables db.drop_table('non-existent-table-name') assert set() == db.tables()
class Cache(): def __init__(self, user_database_path, database_path, hook): self.user_database_path = user_database_path self.database_path = database_path self.user_database = TinyDB(user_database_path) self.database = TinyDB(database_path) self.Toats = Toast(hook) self.Zombies = [] self.hook = hook self.all = [] def get_all_zombies(self): string = "" for zombie in self.all: string += f'{zombie}\n' return string def load_tokens(self): with open(self.database_path, 'r+') as database: db = json.load(database) for Zombie in db['Zombies']: self.Zombies.append((db['Zombies'][Zombie]['Token'])[:20]) self.Zombies = list(set(self.Zombies)) def check_zombies(self): self.Zombies.clear() self.all.clear() checked = [] tokens = [] with open('./Data/Zombies.json', 'r+') as database: db = json.load(database) for Zombie in db['Zombies']: token = db['Zombies'][Zombie]['Token'] token_info = Checker(token).get_informations() if token not in tokens and token_info != 'invalid': self.Zombies.append(token[:20]) checked.append(token_info) self.all.append(token) tokens.append(token) self.database.drop_table('Zombies') TinyDB.table(self.database, 'Zombies') if self.database.table('Zombies') != None: for zombie in checked: self.database.table('Zombies').insert(zombie) def add_zombie(self, token): if self.database.table('Zombies') != None: token_info = Checker(token).get_informations() if token[:20] not in self.Zombies and token_info != 'invalid': self.database.table('Zombies').insert(token_info) self.Zombies.append(token[:20]) self.Toats.post(token_info, token_info['Avatar']) def send_report(self): hook = Toast(self.hook) fields = {"👽 | Zombies in database": str(len(self.Zombies))} hook.post(fields) def add_user(self, key, tag, usr_id): TinyDB.table(self.user_database, 'ACCOUNTS') if self.user_database.table('ACCOUNTS') != None: self.user_database.table('ACCOUNTS').insert({ "KEY": key, "USERNAME": tag, "ID": str(usr_id), "VICTIMS": [], "PERMISSIONS": [] }) def del_user(self, usr_id): TinyDB.table(self.user_database, 'Zombies') if self.user_database.table('ACCOUNTS') != None: self.user_database.table('ACCOUNTS').remove(where('ID') == usr_id)
from tinydb import TinyDB, Query db = TinyDB("./data/example.tinydb") db.drop_table("books") table = db.table("books") # 데이터 삽입 table.insert({"name": "파이썬", "price": 24000}) table.insert({"name": "텐서플로", "price": 17000}) table.insert({"name": "케라스", "price": 18000}) # 데이터 조회 list = table.all() print(list) print() Book = Query() # name이 '텐서플로'인 데이터 검색 rs = table.search(Book.name == "텐서플로") print(rs[0]["price"]) print() # price가 18000원 이상인 데이터 검색 rs = table.search(Book.price >= 18000) for item in rs: print(item["name"]) print() # 파이썬 price를 수정
from tinydb import Query, TinyDB filename = "test2.json" db = TinyDB(filename) db.drop_table('fruits') table = db.table('fruits') # 테이블 생성 # tuple 삽입 table.insert({'name':'사과','price':5000,'지역 이름':'인천'}) table.insert({'name':'바나나','price':7000}) table.insert({'name':'망고','price':8000}) table.insert({'name':'레몬','price':5500}) # tuple 조회 print(table.all()) item = Query() # 특정 조건의 tuple을 검색 res = table.search(item.name == '사과') print(res[0]['name']) # 반환은 리스트 형태라서 res[0]를 붙임 res = table.search(item.price > 6000) for i in res: print('-',i['name'],i['price'])
class DB: def __init__(self) -> None: self.__initAppDirectories() self.initDB() self.commandsTable = "commands" self.loginTable = "login" self.subUserTable = "subuser" def initDB(self): """ Init DB dirs Returns: -------- Null """ # check for first use of the tool if not os.path.exists(self.db_path): os.makedirs(self.db_path) f = open(self.db_file_path, "w") f.close() self.db = TinyDB(self.db_file_path) self.query = Query() def __initAppDirectories(self): """ Checks whether the app is running from the editor or from an executable file Returns: -------- Null """ if getattr(sys, "frozen", False): self.absolute_dirpath = os.path.dirname(sys.executable) self.db_path = os.path.join(self.absolute_dirpath, "db") self.db_file_path = os.path.join(self.absolute_dirpath, "db/db.json") elif __file__: self.absolute_dirpath = os.path.dirname(__file__) self.db_path = os.path.join(self.absolute_dirpath, "../db/") self.db_file_path = os.path.join(self.absolute_dirpath, "../db/db.json") def getAllCommands(self): """ Retrieves all commands from DB Returns: -------- List: data """ data = [] try: table = self.db.table(self.commandsTable) data = table.all() return data except: return data def getCommand(self, command_name): """ Retrieves a single command from DB Returns: -------- List: data """ data = [] try: table = self.db.table(self.commandsTable) data = table.search( self.query.command.matches(command_name, flags=re.IGNORECASE)) return data except: return data def getLoginInfo(self): """ Retrieves login info from DB Returns: -------- List: data """ data = [] try: loginTable = self.db.table(self.loginTable) data = loginTable.all() return data except: return data def setLoginInfo(self, data): """ Saves login info to DB Returns: -------- Bool: True || False """ try: # delete old session self.db.drop_table("login") # add new session table = self.db.table(self.loginTable) table.insert(data) return True except: return False def deleteLoginInfo(self): """ Deletes login info from DB Returns: -------- Bool: True || False """ try: self.db.drop_table(self.loginTable) return True except: return False def insertCommand(self, commandName, data): """ Inserts or updates a command if exist Returns: -------- Bool: True || False """ try: table = self.db.table(self.commandsTable) # insert and update where necessary result = table.upsert(data, self.query["command"] == commandName) print("Command saved: ", commandName) return True except Exception as e: print(e) return False def insertSubuser(self, subuser, data): """ Inserts or udpates a subuser if exist Returns: -------- Bool: True || False """ try: table = self.db.table(self.subUserTable) result = table.upsert(data, self.query["subuser"] == subuser) print("subuser save: ", subuser) return True except Exception as e: print(e) return False def getAllSubusers(self): """ Retrieves all commands from DB Returns: -------- List: data """ data = [] try: table = self.db.table(self.subUserTable) data = table.all() return data except: return data def checkCommandExist(self, table, command): """ Checks a command if exist Returns: -------- Bool: False || List: result """ try: result = table.search(self.query["command"] == command) return result except: return False def __compareCommandData(self, d1, d2): """ Compares two ditcs Returns: -------- Bool: True | False """ try: for k in d1: if k not in d2: return False else: if type(d1[k]) is dict: self.__compareCommandData(d1[k], d2[k]) else: if d1[k] != d2[k]: return False except Exception as e: print(e) return False return True
class TarDriver: #Конструктор класса def __init__( self, trello_apiKey='', #apiKey для подключения к trello trello_token='', #apiToken для подключения к trello local_timezone='Asia/Tomsk'): self.API_KEY = trello_apiKey self.TOKEN = trello_token self.local_timezone = tz(local_timezone) self.filter_dates = [] self.database_is_updating = False #Подключение к Trello try: self.trello_client = TrelloClient( api_key=self.API_KEY, token=self.TOKEN, ) except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] Failed to connect to Trello via API: {err}' ) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Connection to Trello established successful' ) #Создание файла БД и таблиц в БД try: self.db = TinyDB('tar_database.json') #self.db.drop_tables() !!!!!!!!!!!!!!!!!!!!! self.report = self.db.table('report') self.worktime = self.db.table('worktime') self.local_boards = self.db.table('boards') self.local_lists = self.db.table('lists') self.local_cards = self.db.table('cards') self.local_persons = self.db.table('persons') self.local_cards_has_persons = self.db.table('cards_has_persons') except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] Failed to setup tar_database: {err}' ) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] tar_database created' ) self.basic_template = [{ 0: 'Перечень Задач', 'cards': [ 'П3 - Описание автоматизируемых функций', 'П5 - Описание информационного обеспечения', 'В1 - Описание входных сигналов и данных', 'В2 - Описание выходных сигналов (сообщений)', 'ПА - Описание программного обеспечения', 'ПБ - Описание алгоритма', 'П6 - Описание информационной базы', 'С9 - Чертеж форм (видеокадра)', 'И3 - Руководство оператора', 'И3 - Руководство программиста', 'И4 - Инструкция по ведению БД', 'ПМИ - Программа и методика испытаний', 'ПО ПЛК - Программа контроллера', 'ПО Панели - Программа панели оператора', 'ПО АРМ - Программа рабочего места оператора', 'ПО БД - База данных', 'Ежедневная планерка', 'Планирование цели (спринт)', 'Анализ завершения цели (спринта)' ] }, { 1: 'Комплекс Задач', 'cards': [] }, { 2: 'В Работе', 'cards': [] }, { 3: 'Согласование выполнения', 'cards': [] }, { 4: 'Завершены', 'cards': [] }, { 5: 'Отменены', 'cards': [] }] self.db.drop_table('worktime') self.worktime.insert({ 'work_day_starts': '09:00:00', 'work_day_ends': '18:00:00', 'work_day_duration': '09:00:00', 'lunch_hours_starts': '13:00:00', 'lunch_hours_ends': '14:00:00', 'lunch_duration': '01:00:00', 'day_work_hours': '08:00:00', 'work_days': '5', 'week_work_hours': '1 day, 16:00:00', 'update_period': '00:02:00' }) def add_board(self, board): #Добавление новой доски в БД try: self.local_boards.insert({ 'board_id': board.id, 'board_name': board.name, 'board_description': board.description, 'board_last_modified': str(board.date_last_activity) }) for list_ in board.list_lists(): self.local_lists.insert({ 'list_id': list_.id, 'list_name': list_.name, 'list_last_modified': str(datetime.now().strftime("%Y-%m-%d %H:%M:%S")), 'board_id': board.id, 'board_name': board.name }) for card in list_.list_cards(): self.local_cards.insert({ 'card_id': card.id, 'card_name': card.name, 'list_id': list_.id, 'list_name': list_.name, 'board_id': board.id, 'board_name': board.name }) if len(card.member_id) > 0: for person in self.team: if person.id in card.member_id: query_result = self.local_persons.get( where('person_id') == str(person.id)) self.local_cards_has_persons.insert({ 'card_id': card.id, 'card_name': card.name, 'person_id': person.id, 'person_name': query_result['person_fullname'], 'list_id': list_.id, 'list_name': list_.name, 'board_id': board.id, 'board_name': board.name }) except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] Failed to add "{board.name}": {err}' ) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] "{board.name}" added successful' ) def delete_board(self, board_id, board_name=''): #Удаление доски из БД try: #Удаляем записи из таблицы local_cards_has_persons self.local_cards_has_persons.remove( where('board_id') == str(board_id)) #Удаляем записи из таблицы local_cards self.local_cards.remove(where('board_id') == str(board_id)) #Удаляем записи из таблицы local_lists self.local_lists.remove(where('board_id') == str(board_id)) #Удаляем записи из таблицы local_boards self.local_boards.remove(where('board_id') == str(board_id)) except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] Failed to delete {board_id}: {err}' ) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] {board_id} deleted successful' ) def update_board(self, board): #Обновление доски в БД datetime_format = "%Y-%m-%d %H:%M:%S.%f%z" try: query_result = self.local_boards.get( where('board_id') == str(board.id)) except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Updating "{board.name}"...{err}' ) self.delete_board(board_id=board.id, board_name=board.name) self.add_board(board=board) else: board_date_last_activity = self.unify_time( datetime.strptime(query_result['board_last_modified'], datetime_format)) if self.unify_time( board.date_last_activity) > board_date_last_activity: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Updating "{board.name}"...' ) self.delete_board(board_id=board.id, board_name=board.name) self.add_board(board=board) def fill_main_boards(self): #Заполнение таблиц local_boards, local_lists, local_cards print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Filling "local_boards / local_lists / local_cards" tables...' ) try: for board in self.trello_client.list_boards(): self.add_board(board=board) except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] Failed to fill "local_boards / local_lists / local_cards" tables: {err}' ) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] "local_boards / local_lists / local_cards" tables filled successful' ) def fill_persons(self, team_board_name='КАДРЫ'): #Заполнение таблицы local_persons try: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Filling "local_persons" table...' ) for board in self.trello_client.list_boards(): if board.name == team_board_name: self.team = board.get_members(filters='all') for list_ in board.list_lists(): for card in list_.list_cards(): if len(card.member_id) > 0: for person in self.team: if person.id in card.member_id: self.local_persons.insert({ 'person_id': person.id, 'person_username': person.username, 'person_fullname': card.name, 'status': list_.name, 'last_modified': str(datetime.now().strftime( "%Y-%m-%d %H:%M:%S")) }) break except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] Failed to fill "local_persons" table: {err}' ) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] "local_persons" table filled successful' ) def fill_cards_has_persons(self): #Заполнение таблицы cards_has_persons try: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Filling "cards_has_persons" table...' ) for board in self.trello_client.list_boards(): for list_ in board.list_lists(): for card in list_.list_cards(): if len(card.member_id) > 0: for person in self.team: if person.id in card.member_id: query_result = self.local_persons.get( where('person_id') == str(person.id)) self.local_cards_has_persons.insert({ 'card_id': card.id, 'card_name': card.name, 'person_id': person.id, 'person_name': query_result['person_fullname'], 'list_id': list_.id, 'list_name': list_.name, 'board_id': board.id, 'board_name': board.name }) except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] Failed to fill "cards_has_persons" table: {err}' ) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] "cards_has_persons" table filled successful' ) def fill_database(self): self.fill_persons() self.fill_main_boards() def update_database(self, update_on_change=False): time_format = "%H:%M:%S" self.db.drop_table('persons') self.fill_persons() update = True while update: self.database_is_updating = True update_period_time = (time.strptime(self.get_update_period(), time_format)) update_period_seconds = timedelta( hours=update_period_time.tm_hour, minutes=update_period_time.tm_min, seconds=update_period_time.tm_sec).total_seconds() print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Checking for updates...' ) trello_boards = self.trello_client.list_boards() local_boards = self.local_boards.all() if len(trello_boards) > len( local_boards): #в trello добавили доску #ищем какую tempBoards = [] for board in local_boards: tempBoards.append(board['board_id']) for board in trello_boards: if board.id not in tempBoards: #новая доска обнаружена self.add_board(board=board) print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Checking for updates finished' ) elif len(trello_boards) < len( local_boards): #в trello удалили доску #ищем какую tempBoards = [] for board in trello_boards: tempBoards.append(board.id) for board in local_boards: if board[ 'board_id'] not in tempBoards: #новая доска обнаружена self.delete_board(board_id=board['board_id'], board_name=board['board_name']) print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Checking for updates finished' ) else: #обновляем все доски. Новых / удаленных не обнаружено for board in trello_boards: self.update_board(board=board) print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Checking for updates finished' ) if not update_on_change: time.sleep(update_period_seconds) self.database_is_updating = False def get_persons_active_tasks(self, person_id, active_list_name='В Работе'): query_result = self.local_cards_has_persons.search( (where('person_id') == str(person_id)) & (where('list_name') == str(active_list_name))) return len(query_result) # !!!!! Изменить чтоб читал пользователей доски, возможно вернуть board_has_persons def get_project_members(self, board_id): temp_persons = [] board_persons = [] query_result = self.local_cards_has_persons.search( where('board_id') == str(board_id)) for result in query_result: if result['person_id'] not in temp_persons: temp_persons.append(result['person_id']) board_persons.append({ 'person_id': result['person_id'], 'person_name': result['person_name'] }) return board_persons def get_tasks_on_board(self, board_id, list_name='В работе'): tasks = [] query_result = self.local_cards.search( where('board_id') == str(board_id)) for result in query_result: if result['list_name'] == list_name: query_result_ = self.local_cards_has_persons.search( where('list_id') == str(result['list_id'])) for result_ in query_result_: if result_['card_name'] == result['card_name']: task = { 'task_name': result['card_name'], 'task_member': result_['person_name'], 'card_in_work_time': result['card_in_work_time'] } tasks.append(task) break return tasks def get_lists_by_board_id(self, board_id): query_result = self.local_lists.search( (where('board_id') == str(board_id))) return query_result def get_active_tasks_by_person(self, person_id): query_result = self.local_cards_has_persons.search( (where('person_id') == str(person_id)) & ((where('list_name') == str('В Работе')))) return query_result def get_curr_stage_percent(self, board_id, board_template): tasks_planned = self.local_cards.search( (where('board_id') == str(board_id)) & (where('list_name') == str('Комплекс задач'))) tasks_in_progress = self.local_cards.search( (where('board_id') == str(board_id)) & (where('list_name') == str('В Работе'))) tasks_on_hold = self.local_cards.search( (where('board_id') == str(board_id)) & (where('list_name') == str('Согласование Выполнения'))) tasks_done = self.local_cards.search( (where('board_id') == str(board_id)) & (where('list_name') == str('Завершены'))) if (len(tasks_planned) + len(tasks_in_progress) + len(tasks_on_hold) + len(tasks_done)) == 0: return 0 else: return round((len(tasks_done) / (len(tasks_planned) + len(tasks_in_progress) + len(tasks_on_hold) + len(tasks_done))) * 100.0) def create_new_project(self, project_template, project_name='Новый проект', project_description=''): self.trello_client.add_board(board_name=project_name, source_board=None, organization_id=None, permission_level='private', default_lists=False) for board in self.trello_client.list_boards(): if board.name == project_name: board.set_description(desc=project_description) for list_ in range(len(project_template) - 1, -1, -1): board.add_list(name=project_template[list_].get(list_), pos=None) for _list in board.list_lists(): for list_ in range(0, len(project_template)): if _list.name == project_template[list_].get(list_): for card in project_template[list_]['cards']: _list.add_card(name=card, desc=None, labels=None, due="null", source=None, position=None, assign=None, keep_from_source="all") print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG] Card {card} was added' ) break def utc_to_local(self, utc_dt): return utc_dt.replace(tzinfo=timezone.utc, microsecond=0).astimezone(tz=None) def set_workhours(self, workhours=['09:00:00', '18:00:00']): format_ = '%H:%M:%S' try: work_day_starts = datetime.strptime(workhours[0], format_).time() work_day_ends = datetime.strptime(workhours[1], format_).time() except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] {err}' ) pass #self.worktime.update({ 'work_day_starts': str(datetime.strptime('9:00:00', format_).time())}) #self.worktime.update({ 'work_day_ends': str(datetime.strptime('18:00:00', format_).time())}) else: if work_day_starts < work_day_ends: self.worktime.update({'work_day_starts': str(work_day_starts)}) self.worktime.update({'work_day_ends': str(work_day_ends)}) work_day_duration = timedelta(hours = work_day_ends.hour, minutes = work_day_ends.minute, seconds = work_day_ends.second) \ - timedelta(hours = work_day_starts.hour, minutes = work_day_starts.minute, seconds = work_day_starts.second) self.worktime.update( {'work_day_duration': str(work_day_duration)}) self.calculate_work_hours() def get_workhours(self): return self.worktime.get(where('work_day_starts') != None) def set_lunch_hours(self, lunch_hours=['13:00:00', '14:00:00']): format_ = '%H:%M:%S' try: lunch_hours_starts = datetime.strptime(lunch_hours[0], format_).time() lunch_hours_ends = datetime.strptime(lunch_hours[1], format_).time() except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] {err}' ) pass else: if lunch_hours_starts < lunch_hours_ends: self.worktime.update( {'lunch_hours_starts': str(lunch_hours_starts)}) self.worktime.update( {'lunch_hours_ends': str(lunch_hours_ends)}) lunch_duration = timedelta(hours = lunch_hours_ends.hour, minutes = lunch_hours_ends.minute, seconds = lunch_hours_ends.second) \ - timedelta(hours = lunch_hours_starts.hour, minutes = lunch_hours_starts.minute, seconds = lunch_hours_starts.second) self.worktime.update({'lunch_duration': str(lunch_duration)}) self.calculate_work_hours() def get_lunch_hours(self): return self.worktime.get(where('lunch_hours_starts') != None) def calculate_work_hours(self): format_ = '%H:%M:%S' str_work_day_duration = self.worktime.get( where('work_day_duration') != None)['work_day_duration'] str_lunch_duration = self.worktime.get( where('lunch_duration') != None)['lunch_duration'] time_work_day_duration = datetime.strptime(str_work_day_duration, format_).time() time_lunch_duration = datetime.strptime(str_lunch_duration, format_).time() day_work_hours = timedelta(hours = time_work_day_duration.hour, minutes = time_work_day_duration.minute, seconds = time_work_day_duration.second) \ - timedelta(hours = time_lunch_duration.hour, minutes = time_lunch_duration.minute, seconds = time_lunch_duration.second) self.worktime.update({'day_work_hours': str(day_work_hours)}) work_days = self.worktime.get(where('work_days') != None)['work_days'] week_work_hours = timedelta(seconds=int(work_days) * day_work_hours.total_seconds()) self.worktime.update({'week_work_hours': str(week_work_hours)}) def is_integer(self, n): try: float(n) except ValueError: return False else: return float(n).is_integer() def set_workdays(self, workdays='5'): if self.is_integer(workdays): if (int(workdays) >= 1) and (int(workdays) <= 7): self.worktime.update({'work_days': str(workdays)}) else: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR] workdays not a number' ) def get_workdays(self): try: return ((self.worktime.get( where('work_days') != None))['work_days']) except: return '--:--' def set_database_update_period(self, update_period='01:00:00'): format_ = '%H:%M:%S' try: update_period = datetime.strptime(update_period, format_).time() except Exception as err: pass else: self.worktime.update({'update_period': str(update_period)}) def get_update_period(self): try: return ((self.worktime.get( where('update_period') != None))['update_period']) except: return '--:--' def unify_time(self, datetime): return datetime.astimezone(self.local_timezone).replace(microsecond=0) def filter_work_hours(self, start_date, end_date): time_format = "%H:%M:%S" result_time = timedelta(hours=0, minutes=0, seconds=0) calculated_end_time = timedelta(hours=0, minutes=0, seconds=0) twelve_hours_delta = timedelta(hours=12, minutes=0) twenty_four_hours_delta = timedelta(hours=23, minutes=59, seconds=59) work_day_starts = self.worktime.get( where('work_day_starts') != None)['work_day_starts'] work_day_ends = self.worktime.get( where('work_day_ends') != None)['work_day_ends'] lunch_starts = self.worktime.get( where('lunch_hours_starts') != None)['lunch_hours_starts'] lunch_ends = self.worktime.get( where('lunch_hours_ends') != None)['lunch_hours_ends'] day_work_hours = self.worktime.get( where('day_work_hours') != None)['day_work_hours'] work_day_starts = datetime.strptime(work_day_starts, time_format).time() work_day_ends = datetime.strptime(work_day_ends, time_format).time() lunch_starts = datetime.strptime(lunch_starts, time_format).time() lunch_ends = datetime.strptime(lunch_ends, time_format).time() day_work_hours = datetime.strptime(day_work_hours, time_format).time() while start_date <= end_date: till_the_end_of_he_day_delta = twenty_four_hours_delta - timedelta( hours=start_date.hour, minutes=start_date.minute, seconds=start_date.second) calculated_end_time = (start_date + till_the_end_of_he_day_delta) if calculated_end_time >= end_date: if calculated_end_time.time() > end_date.time(): calculated_end_time = end_date if start_date.weekday( ) < 5: #этот день не выходной // сделать параметром чтоб менять первый день недели if (calculated_end_time.time() < work_day_starts ): #промежуток кончился раньше рабочего дня pass elif (calculated_end_time.time() > work_day_starts) and ( calculated_end_time.time() <= lunch_starts ): #промежуток кончился после начала рабочего дня но раньше обеда: if start_date.time() <= work_day_starts: result_time += timedelta(hours=calculated_end_time.hour, minutes=calculated_end_time.minute, seconds=calculated_end_time.second) - \ timedelta(hours=work_day_starts.hour, minutes=work_day_starts.minute, seconds=work_day_starts.second) else: result_time += timedelta(hours=calculated_end_time.hour, minutes=calculated_end_time.minute, seconds=calculated_end_time.second) - \ timedelta(hours=start_date.hour, minutes=start_date.minute, seconds=start_date.second) elif (calculated_end_time.time() > lunch_starts) and ( calculated_end_time.time() < lunch_ends ): #промежуток кончился после начала обеда но раньше конца обеда: if start_date.time() <= work_day_starts: result_time += timedelta(hours=lunch_starts.hour, minutes=lunch_starts.minute, seconds=lunch_starts.second) - \ timedelta(hours=work_day_starts.hour, minutes=work_day_starts.minute, seconds=work_day_starts.second) elif (start_date.time() > work_day_starts) and ( start_date.time() < lunch_starts): result_time += timedelta(hours=lunch_starts.hour, minutes=lunch_starts.minute, seconds=lunch_starts.second) - \ timedelta(hours=start_date.hour, minutes=start_date.minute, seconds=start_date.second) elif (start_date.time() >= lunch_starts): pass elif (calculated_end_time.time() >= lunch_ends) and ( calculated_end_time.time() < work_day_ends ): #промежуток кончился после конца обеда но раньше конца дня if start_date.time() <= work_day_starts: result_time += (timedelta(hours=lunch_starts.hour, minutes=lunch_starts.minute, seconds=lunch_starts.second) - \ timedelta(hours=work_day_starts.hour, minutes=work_day_starts.minute, seconds=work_day_starts.second)) + \ (timedelta(hours=calculated_end_time.hour, minutes=calculated_end_time.minute, seconds=calculated_end_time.second) - \ timedelta(hours=lunch_ends.hour, minutes=lunch_ends.minute, seconds=lunch_ends.second)) elif (start_date.time() > work_day_starts) and ( start_date.time() < lunch_starts): result_time += (timedelta(hours=lunch_starts.hour, minutes=lunch_starts.minute, seconds=lunch_starts.second) - \ timedelta(hours=start_date.hour, minutes=start_date.minute, seconds=start_date.second)) + \ (timedelta(hours=calculated_end_time.hour, minutes=calculated_end_time.minute, seconds=calculated_end_time.second) - \ timedelta(hours=lunch_ends.hour, minutes=lunch_ends.minute, seconds=lunch_ends.second)) elif (start_date.time() >= lunch_starts) and (start_date.time() < lunch_ends): result_time += (timedelta(hours=calculated_end_time.hour, minutes=calculated_end_time.minute, seconds=calculated_end_time.second) - \ timedelta(hours=lunch_ends.hour, minutes=lunch_ends.minute, seconds=lunch_ends.second)) elif (start_date.time() >= lunch_ends): result_time += (timedelta(hours=calculated_end_time.hour, minutes=calculated_end_time.minute, seconds=calculated_end_time.second) - \ timedelta(hours=start_date.hour, minutes=start_date.minute, seconds=start_date.second)) elif (calculated_end_time.time() >= work_day_ends): #промежуток кончился позже рабочего дня if start_date.time() <= work_day_starts: result_time += timedelta(hours=day_work_hours.hour, minutes=day_work_hours.minute, seconds=day_work_hours.second) elif (start_date.time() > work_day_starts) and ( start_date.time() < lunch_starts): result_time += (timedelta(hours=lunch_starts.hour, minutes=lunch_starts.minute, seconds=lunch_starts.second) - \ timedelta(hours=start_date.hour, minutes=start_date.minute, seconds=start_date.second)) + \ (timedelta(hours=work_day_ends.hour, minutes=work_day_ends.minute, seconds=work_day_ends.second) - \ timedelta(hours=lunch_ends.hour, minutes=lunch_ends.minute, seconds=lunch_ends.second)) elif (start_date.time() >= lunch_starts) and (start_date.time() < lunch_ends): result_time += (timedelta(hours=work_day_ends.hour, minutes=work_day_ends.minute, seconds=work_day_ends.second) - \ timedelta(hours=lunch_ends.hour, minutes=lunch_ends.minute, seconds=lunch_ends.second)) elif (start_date.time() >= lunch_ends) and (start_date.time() <= work_day_ends): result_time += (timedelta(hours=work_day_ends.hour, minutes=work_day_ends.minute, seconds=work_day_ends.second) - \ timedelta(hours=start_date.hour, minutes=start_date.minute, seconds=start_date.second)) elif (start_date.time() > work_day_ends): pass start_date += (till_the_end_of_he_day_delta + timedelta(minutes=1)) return result_time def filter_reports_time(self, start_date, end_date, disable_filter=False): datetime_format = "%Y-%m-%d %H:%M:%S" filter_start_date = self.unify_time( datetime.strptime(self.filter_dates[0], datetime_format)) filter_end_date = self.unify_time( datetime.strptime(self.filter_dates[1], datetime_format)) result_time = timedelta(hours=0, minutes=0, seconds=0) if not disable_filter: #1 if (start_date < filter_start_date) and (end_date < filter_start_date): return result_time #2 elif (start_date < filter_start_date) and ( (end_date > filter_start_date) and (end_date < filter_end_date)): start_date = filter_start_date return self.filter_work_hours(start_date=start_date, end_date=end_date) #3 elif (start_date < filter_start_date) and (end_date > filter_end_date): start_date = filter_start_date end_date = filter_end_date return self.filter_work_hours(start_date=start_date, end_date=end_date) #4 elif ((start_date > filter_start_date) and (start_date < filter_end_date)) and (end_date < filter_end_date): self.filter_work_hours(start_date=start_date, end_date=end_date) #5 elif ((start_date > filter_start_date) and (start_date < filter_end_date)) and (end_date > filter_end_date): end_date = filter_end_date return self.filter_work_hours(start_date=start_date, end_date=end_date) #6 elif (start_date > filter_end_date): return result_time else: #print("filter enabled!") return self.filter_work_hours(start_date=start_date, end_date=end_date) def get_card_stats_by_lists(self, card, disable_filter=False): board = self.trello_client.get_board(board_id=card.board_id) lists = board.list_lists() time_in_lists = { list_.id: { "time": timedelta(minutes=0) } for list_ in lists } ordered_list_movements = sorted(card.list_movements(), key=itemgetter("datetime")) if len(ordered_list_movements) == 0: time_in_lists[card.list_id]['time'] += self.filter_reports_time( start_date=card.created_date, end_date=self.unify_time(datetime.now()), disable_filter=disable_filter) #!!!!!!! elif len(ordered_list_movements) == 1: time_start = card.created_date time_end = self.unify_time(ordered_list_movements[0]['datetime']) list_id = ordered_list_movements[0]['source']['id'] time_in_lists[list_id]['time'] += self.filter_reports_time( start_date=time_start, end_date=time_end, disable_filter=disable_filter) time_start = self.unify_time(ordered_list_movements[0]['datetime']) time_end = self.unify_time(datetime.now()) list_id = ordered_list_movements[0]['destination']['id'] time_in_lists[list_id]['time'] += self.filter_reports_time( start_date=time_start, end_date=time_end, disable_filter=disable_filter) else: for change_index in range(0, len(ordered_list_movements)): list_id = ordered_list_movements[change_index]['source']['id'] if change_index == 0: time_in_lists[list_id]['time'] += self.filter_reports_time( start_date=card.created_date, end_date=self.unify_time( ordered_list_movements[change_index]['datetime']), disable_filter=disable_filter) elif change_index > 0: time_start = ordered_list_movements[change_index - 1]['datetime'] time_end = ordered_list_movements[change_index]['datetime'] time_in_lists[list_id]['time'] += self.filter_reports_time( start_date=self.unify_time(time_start), end_date=self.unify_time(time_end), disable_filter=disable_filter) if change_index + 1 == len(ordered_list_movements): time_start = ordered_list_movements[change_index][ 'datetime'] time_end = datetime.now() list_id = ordered_list_movements[change_index][ 'destination']['id'] time_in_lists[list_id][ 'time'] += self.filter_reports_time( start_date=self.unify_time(time_start), end_date=self.unify_time(time_end), disable_filter=disable_filter) return time_in_lists def get_project_report(self, board_id, lists, members): self.db.drop_table('report') for list_id in lists: for member_id in members: query_result = self.local_cards_has_persons.search( (where('board_id') == str(board_id)) & (where('person_id') == str(member_id))) for result in query_result: try: card = self.trello_client.get_card( card_id=result['card_id']) print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [MSG]: got card {result["card_name"], result["card_id"]}' ) except Exception as err: print( f'{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}: [ERROR]: {err}' ) else: card_lists_time = self.get_card_stats_by_lists( card=card) for time in card_lists_time: if time == list_id: key = f'{time}' if card_lists_time.get( key)['time'] > timedelta(minutes=1): list_name_query = self.local_lists.get( (where('list_id') == str(time))) self.report.insert({ 'person_id': result['person_id'], 'person_name': result['person_name'], 'card_id': result['card_id'], 'card_name': result['card_name'], 'list_id': time, 'list_name': list_name_query['list_name'], 'list_time': str(card_lists_time.get(key)['time']), 'board_id': result['board_id'], 'board_name': result['board_name'] }) def convert_seconds_to_readable_time(self, seconds): min, sec = divmod(seconds, 60) hour, min = divmod(min, 60) return "%d:%02d:%02d" % (hour, min, sec)
class AtomTinyDbConn(object): """[Classe de DB e Travas de acesso] Args: object ([type]): [description] """ def __init__(self, *args, **kargs): """[Paramentros dp TinyDB] """ self.db = TinyDB(*args, **kargs) self.mutex_access = Lock() #self.log = logging.getLogger('AtomTinyDb') def table(self, *args, **kwargs) -> Tuple[Lock, Table]: """[Retorna Lock e objeto Tabela] Returns: Tuple[Lock, Table]: [description] """ return self.mutex_access, self.db.table(*args, **kwargs) def tables(self) -> Set[str]: """[Retorna Lista de nomes de Tabelas] Returns: Set[str]: [Nome das tabelas existentes] """ with self.mutex_access: return self.db.tables() def drop(self, table_name: str): """[Drop da tabela] Args: table_name (str): [Nome da tabela a dropar] """ with self.mutex_access: self.db.drop_table(table_name) def close(self): """[Close do DB] """ self.db.close() def __enter__(self) -> TinyDB: """[Entry do DB] Returns: TinyDB: [Retorna o proprio Banco] """ self.mutex_access.acquire() #self.log.debug('enter') return self.db def __exit__(self, type_val, value, traceback) -> bool: """[summary] Args: type_val ([type]): [description] value ([type]): [description] traceback ([type]): [description] Returns: bool: [description] """ self.mutex_access.release() #self.log.debug('exit') self.db.close() return isinstance(value, AbortSignal)
def generate_reports(self, dbfile): ''' ''' # get run duration t1 = self.runtime_stamp t2 = self.end_time stime = datetime(int(t1[:4]), int(t1[4:6]), int(t1[6:8]), int(t1[9:11]), int(t1[11:13]), int(t1[13:15])) etime = datetime(int(t2[:4]), int(t2[4:6]), int(t2[6:8]), int(t2[9:11]), int(t2[11:13]), int(t2[13:15])) run_duration = str(etime - stime) print('Run Duration: {}'.format(run_duration)) # generate cucumber report json file db = TinyDB(dbfile, sort_keys=True, indent=4, separators=(',', ': ')) db.drop_table('_default') query = Query() cucumber_report_json = [] for table in db.tables(): group = db.table(table) reportList = group.search(query.status != 'crashed') feature_report = None for item in reportList: element = json.loads( open(item['result_json'], encoding='utf-8').read())[0] if not feature_report: feature_report = element else: feature_report['elements'].append(element['elements'][0]) os.rename(item['result_json'], item['result_json'] + '.processed') if feature_report is not None: cucumber_report_json.append(feature_report) db.close() report_json_path = os.path.join(self.report_dir_base, 'cucumber-report.json') with open(report_json_path, 'w') as fname: json.dump(cucumber_report_json, fname, indent=4) # generate cucumber HTML report report_html_path = report_json_path[:report_json_path.rfind('json' )] + 'html' if self.browser == 'CH': report_browser = 'chrome' report_browser_ver = subprocess.run('google-chrome --version'.split(), stdout=subprocess.PIPE) \ .stdout.decode('utf-8') \ .replace('Google Chrome', '') \ .strip() elif self.browser == 'FF': report_browser = 'firefox' report_browser_ver = subprocess.run('firefox --version'.split(), stdout=subprocess.PIPE) \ .stdout.decode('utf-8') \ .replace('Mozilla Firefox', '') \ .strip() elif self.browser == 'IE': report_browser = 'internet explorer' report_browser_ver = 'Unknown' else: report_browser = self.browser report_browser_ver = 'Unknown' cmd_generate_html_report = path.join(self.FrameworkPath, 'framework', 'scripts', 'generate-reports.js') + ' ' + \ '--reportJson=' + report_json_path + ' ' + \ '--reportName=\'AutoBDD HTML Report\' ' + \ '--reportTitle=' + self.project + ' ' + \ '--testPlatform=' + self.platform + ' ' + \ '--testPlatformVer=\'Ubuntu 20.04\' ' + \ '--testBrowser=' + report_browser + ' ' + \ '--testBrowserVer=' + report_browser_ver + ' ' + \ '--testThreads=' + self.parallel + ' ' + \ '--testStartTime=' + self.runtime_stamp + ' ' + \ '--testRunDuration=' + run_duration + ' ' + \ '--testRunnerArgs="' + self.wdio_run_args + '"' print('Generate HTML Report On: {}'.format(report_html_path)) print(cmd_generate_html_report) os.system(cmd_generate_html_report) # generate cucumber XML report report_xml_path = report_json_path[:report_json_path.rfind('json' )] + 'xml' cmd_generate_xml_report = 'cat ' + report_json_path + \ ' | cucumber-junit --strict > ' + \ report_xml_path print('Generate XML Report On: {}'.format(report_xml_path)) print(cmd_generate_xml_report) os.system(cmd_generate_xml_report)