6 сем / 1 / mainFile

# -*- coding: utf-8 -*-

# main_path = "cd 'C:/Users/admin/source/repos/UNIVERSITY_repos/3 course/6 sem/mispris/1/furniture.db'"


import sqlite3

path = "C:/Users/admin/source/repos/UNIVERSITY_repos/3 course/6 sem/mispris/1/furniture.db"
# path = "/home/user/repos/mispris/1/furniture.db"

conn = sqlite3.connect(path)
cursor = conn.cursor()
print("\n\nDB has been created/connected\n")

conn.execute("PRAGMA foreign_keys = ON")

# cursor.execute("SELECT sqlite_version()")
# res = cursor.fetchall()
# print(res, '\n')


def create_category_table():
cursor.execute('''CREATE TABLE IF NOT EXISTS category
(id INTEGER PRIMARY KEY AUTOINCREMENT,
id_parent INTEGER,
category_name TEXT UNIQUE,
FOREIGN KEY (id_parent) REFERENCES category(id))''')
conn.commit()


def create_product_table():
cursor.execute('''CREATE TABLE IF NOT EXISTS product
(id INTEGER PRIMARY KEY AUTOINCREMENT,
id_category INTEGER,
product_name TEXT NOT NULL,
quantity INTEGER DEFAULT 0,
price REAL DEFAULT 0,
FOREIGN KEY (id_category) REFERENCES category(id))''')
conn.commit()




def creating_tables():
create_category_table()
create_product_table()

creating_tables()


def dropAllTables():
try:
# Список таблиц в порядке, в котором их нужно удалить (сначала те, которые не содержат внешних ключей)
tables_order = ['category', 'product', 'sqlite_sequence']

# Удаление данных из таблиц с внешними ключами
for table_name in tables_order[::-1]:
cursor.execute(f"DELETE FROM {table_name};")

# Удаление самих таблиц
cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';")
tables = cursor.fetchall()

for table in tables:
table_name = table[0]
cursor.execute(f"DROP TABLE IF EXISTS {table_name};")

conn.commit()

print("Все таблицы успешно удалены.")
except Exception as _ex:
print(f"Произошла ошибка при удалении таблиц: {_ex}")


def is_category_exists(category_name):
cursor.execute("SELECT COUNT(*) FROM category WHERE category_name = ?", (category_name,))
count = cursor.fetchone()[0]
res = count > 0

return res


def is_product_exist(product_name):
cursor.execute("SELECT COUNT(*) FROM product WHERE product_name = ?", (product_name,))
count = cursor.fetchone()[0]
res = count > 0

return res


def add_category(category_name, id_parent=None):
try:
if id_parent is not None:
cursor.execute('''
INSERT INTO category (category_name, id_parent)
VALUES (?, ?)
''', (category_name, id_parent))
else:
cursor.execute('''
INSERT INTO category (category_name, id_parent)
VALUES (?, NULL)
''', (category_name,))
print('Категория успешно добавлена.')
conn.commit()
except Exception as _ex:
print(f'Error {_ex} - такое название категории уже есть!')


def add_subcategory(category_name, subcategory_name):
try:
if is_category_exists(category_name):
# Получаем Id категории
cursor.execute("SELECT id FROM category WHERE category_name = ?", (category_name,))
id_parent_to_set = cursor.fetchone()[0]

add_category(subcategory_name, id_parent_to_set)
conn.commit()
print("Подкатегория успешно добавлена.")

else:
print("Указанная категория/подкатегория не существует.")
except Exception as _ex:
print(f"Произошла ошибка при добавлении подкатегории: {_ex}")


def add_product(product_name, category_name, quantity, price):
try:
if is_category_exists(category_name):
# Получаем id подкатегории по ее названию
cursor.execute("SELECT id FROM category WHERE category_name = ?", (category_name,))
category_id = cursor.fetchone()[0]

# Добавляем новое изделие в таблицу Изделие
cursor.execute("INSERT INTO product (id_category, product_name, quantity, price) VALUES (?, ?, ?, ?)",
(category_id, product_name, quantity, price))
conn.commit()
print("Изделие успешно добавлено.")
else:
print("Указанная подкатегория не существует.")

except Exception as _ex:
print(f"Произошла ошибка при добавлении изделия: {_ex}")


def get_all_categories():
try:
cursor.execute("SELECT * FROM category")
categories_names = cursor.fetchall()

return categories_names

except Exception as _ex:
print(f"Произошла ошибка при получении категорий: {_ex}")
return None

# выводить для каждого конкретного класса продукты
def get_all_products():
try:
cursor.execute("SELECT * FROM product")
products_names = cursor.fetchall()

return products_names

except Exception as _ex:
print(f"Произошла ошибка при получении товаров: {_ex}")
return None


def product_update_price(product_name, new_price):
try:

if is_product_exist(product_name):
cursor.execute("UPDATE product SET price = ? WHERE product_name = ?", (new_price, product_name))
conn.commit()
print('Цена изделия успешно обновлена.')
else:
print('Указанное изделие не существует.')

except Exception as _ex:
print(f"Произошла ошибка при обновлении цены изделия: {_ex}")


def product_update_quantity(product_name, new_quantity):
try:

if is_product_exist(product_name):
cursor.execute("UPDATE product SET quantity = ? WHERE product_name = ?", (new_quantity, product_name))
conn.commit()
print('Количество изделия успешно обновлено.')
else:
print('Указанное изделие не существует.')

except Exception as _ex:
print(f"Произошла ошибка при обновлении цены изделия: {_ex}")


def change_product_category(product_name, new_category):
try:

if is_category_exists(new_category):
# Получаем идентификатор новой категории
cursor.execute("SELECT id FROM category WHERE category_name = ?", (new_category,))
new_category_id = cursor.fetchone()[0]

# Обновляем категорию у изделия
cursor.execute("UPDATE product SET id_category = ? WHERE product_name = ?", (new_category_id, product_name))
conn.commit()
print('Категория изделия успешно изменена.')
else:
print('Указанная новая подкатегория не существует.')

except Exception as e:
print(f"Произошла ошибка при изменении подкатегории изделия: {e}")


def delete_product(product_name):
try:

# Удаление изделия
cursor.execute("DELETE FROM product WHERE product_name = ?", (product_name,))
rows_deleted = cursor.rowcount

if rows_deleted > 0:
print('Изделие успешно удалено.')
else:
print('Изделие с указанным названием не найдено.')

conn.commit()

except Exception as _ex:
print(f"Произошла ошибка при удалении изделия: {_ex}")


def delete_category(category_name):
try:

if is_category_exists(category_name):
# Получаем идентификатор удаляемой категории
cursor.execute("SELECT id FROM category WHERE category_name = ?;", (category_name,))
delete_id = cursor.fetchone()[0]

# Перемещаем все подкатегории удаляемой категории в категорию "неопределенные"
cursor.execute("UPDATE category SET id_parent = (SELECT id FROM category WHERE category_name = 'неопределенные') WHERE id_parent = ?", (delete_id,))

# Перемещаем все изделия удаляемой категории в категорию "неопределенные"
cursor.execute("UPDATE product SET id_category = (SELECT id FROM category WHERE category_name = 'неопределенные') WHERE id_category = ?", (delete_id,))

# Удаляем категорию
cursor.execute("DELETE FROM category WHERE id = ?", (delete_id,))
conn.commit()

print('Категория успешно удалена.')
else:
print('Указанная категория не существует.')

except Exception as _ex:
print(f"Произошла ошибка при удалении категории: {_ex}")

# here coursework ends

def delete_subcategory(subcategory_name):
try:

if is_category_exists(subcategory_name):
# Получаем идентификатор удаляемой подкатегории
cursor.execute("SELECT id FROM category WHERE category_name = ?", (subcategory_name,))
subcategory_id = cursor.fetchone()[0]

# Перемещаем связанные изделия в категорию "неопределенные"
cursor.execute("UPDATE product SET id_category = (SELECT id FROM category WHERE category_name = 'неопределенные') WHERE id_category = ?", (subcategory_id,))

# Перемещаем связанные подкатегории в категорию "неопределенные"
cursor.execute("UPDATE category SET id_parent = (SELECT id FROM category WHERE category_name = 'неопределенные') WHERE id_parent = ?", (subcategory_id,))

# Удаляем подкатегорию
cursor.execute("DELETE FROM category WHERE id = ?", (subcategory_id,))
conn.commit()

print('Подкатегория успешно удалена.')
else:
print('Указанная подкатегория не существует.')

except Exception as _ex:
print(f"Произошла ошибка при удалении подкатегории: {_ex}")


def get_subcategory_parent(subcategory_name):
try:

if is_category_exists(subcategory_name):
cursor.execute("SELECT id_parent FROM category WHERE category_name = ?", (subcategory_name,))
id_parent_category_of_subcategory = cursor.fetchone()[0]

cursor.execute("SELECT category_name FROM category WHERE id = ?", (id_parent_category_of_subcategory,))
parent_category_name = cursor.fetchone()[0]

return parent_category_name
else:
print('Указанной подкатегории не существует!')

except Exception as _ex:
print(f"Произошла ошибка при получении родительской категории подкатегории: {_ex}")


def check_cyclic_dependency(new_parent_id, category_id):
def fetch_parent_category(cat_id):
cursor.execute("SELECT id_parent FROM category WHERE id = ?", (cat_id,))
return cursor.fetchone()[0]

current_id = new_parent_id
while current_id is not None:
if current_id == category_id:
return True
current_id = fetch_parent_category(current_id)
return False



def change_parent_of_subcategory(category_name, new_parent_category=None):
try:
print(f'введенные категории - для {category_name} назначить родителем {new_parent_category}')

if (is_category_exists(category_name)):
cursor.execute("SELECT id FROM category WHERE category_name = ?", (category_name,))
id_category = cursor.fetchone()[0]

if (new_parent_category is not None):
if (is_category_exists(new_parent_category)):

if (category_name == new_parent_category):
print('Нельзя назначить категории саму себя в родители.')
return

cursor.execute("SELECT id FROM category WHERE category_name = ?", (new_parent_category,))
id_new_parent_category = cursor.fetchone()[0]

cursor.execute("SELECT id_parent FROM category WHERE category_name = ?", (category_name,))
id_parent_category_of_category = cursor.fetchone()[0]

# Check for cyclic dependency using the recursive function
if check_cyclic_dependency(id_new_parent_category, id_category):

if (id_parent_category_of_category):
# if parent category has had their own parent then would set it

cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_new_parent_category, id_category))

conn.commit()

cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_parent_category_of_category, id_new_parent_category ))

conn.commit()

print('Родитель у подкатегории был успешно изменен.')

else:
# if not then category becomes root
cursor.execute("UPDATE category SET id_parent = ? WHERE category_name = ?", (None, new_parent_category))

conn.commit()
print(f'Подкатегория c category_name {new_parent_category} стала родительской.')

# Update the parent category
cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_new_parent_category, id_category ))

conn.commit()

else:
print('Новая родительская категория не существует.')

else:
# code for new_parent_category=None
cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (None, id_category))

conn.commit()

print('Категория стала корневой / одной из корневых')

else:
print('Указанной категории не существует.')

except Exception as _ex:
conn.rollback()
print(f"Ошибка в изменении родителя категории: {_ex}")



# def change_parent_of_subcategory(category_name, new_parent_category=None):
# try:
# print(f'введенные категории - для f{category_name} назначить родителем f{new_parent_category}')

# if (is_category_exists(category_name)):
# cursor.execute("SELECT id FROM category WHERE category_name = ?", (category_name,))
# id_category = cursor.fetchone()[0]
# print(f'id_category y стулья - {id_category}')

# cursor.execute("SELECT id_parent FROM category WHERE category_name = ?", (category_name,))
# is_category_name_root = cursor.fetchone()[0]

# print(f'is_category_name_root - {is_category_name_root}') #####

# if (new_parent_category is not None):
# if (is_category_exists(new_parent_category)):

# if (category_name == new_parent_category):
# print('Нельзя назначить категории саму себя в родители.')
# return

# cursor.execute("SELECT id FROM category WHERE category_name = ?", (new_parent_category,))
# id_new_parent_category = cursor.fetchone()[0]
# print(f'id_new_parent_category - новое id для родителя у стульев (id стулья-пластик) - {id_new_parent_category}')

# # поменять родителя в цикле
# cursor.execute("SELECT id_parent FROM category WHERE category_name = ?", (category_name,))
# id_parent_category_of_category = cursor.fetchone()[0]

# print(f'id_parent_category_of_category родительское у new_parent_category - {id_parent_category_of_category}')

# # Check for cyclic dependency using the recursive function
# if check_cyclic_dependency(id_new_parent_category, id_category):
# print('check_cyclic_dependency - да')
# # raise ValueError('Нельзя назначить категорию родителем для самой себя или своего потомка')

# # # Update the parent category
# # cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_new_parent_category, id_category))



# if (id_parent_category_of_category):
# print('зашел в if (id_parent_category_of_category)')
# # if parent category has had their own parent then would set it

# # cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_parent_category_of_category, id_category))

# print(f'new_parent_category - {new_parent_category} == стулья-пластик?')

# cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_new_parent_category, id_category))
# conn.commit()
# print(f'для id - {id_category} id_parent теперь - {id_new_parent_category}')

# cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_parent_category_of_category, id_new_parent_category ))
# conn.commit()
# print(f'для id - {id_new_parent_category} id_parent теперь - {id_parent_category_of_category}')


# print('Родитель у подкатегории был успешно изменен.')

# else:
# # if not then category becomes root

# print(f'id (id_category) - {id_category} - probably id of \"изделия\"')

# cursor.execute("SELECT id_parent FROM category WHERE id = ?", (id_category,))
# new_id_parent = cursor.fetchone()[0]

# cursor.execute("UPDATE category SET id_parent = ? WHERE category_name = ?", (None, new_parent_category))
# # cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (None, id_category))
# conn.commit()
# print(f'Подкатегория c category_name {new_parent_category} стала родительской.')


# # Update the parent category
# # cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_new_parent_category, id_category))

# cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (id_new_parent_category, id_category )) # !!!!!!

# conn.commit()

# else:
# print('Новая родительская категория не существует.')

# else:
# # код для new_parent_category=None
# cursor.execute("UPDATE category SET id_parent = ? WHERE id = ?", (None, id_category)) #deleted first None#
# conn.commit()

# print('Категория стала корневой / одной из корневых')

# else:
# print('Указанной категории не существует.')

# except Exception as _ex:
# conn.rollback()
# print(f"Ошибка в изменении родителя категории: {_ex}")


def change_category_name(old_name, new_name):
try:

if is_category_exists(old_name):
if not is_category_exists(new_name):
cursor.execute("SELECT id FROM category WHERE category_name = ?", (old_name,))
category_name_id = cursor.fetchone()[0]

cursor.execute("UPDATE category SET category_name = ? WHERE id = ?", (new_name, category_name_id))
print('Имя категории успешно изменено.')
else:
print('Указанное новое имя категории уже существует!')

else:
print('Указанная категория не существует.')

conn.commit()

except Exception as _ex:
print(f"Произошла ошибка при изменении имени категории: {_ex}")


def change_product_name(old_name, new_name):
try:

if is_product_exist(old_name):
if not is_product_exist(new_name):
cursor.execute("SELECT id FROM product WHERE product_name = ?", (old_name,))
product_name_id = cursor.fetchone()[0]

cursor.execute("UPDATE product SET product_name = ? WHERE id = ?", (new_name, product_name_id))
print('Имя изделия успешно изменено.')
else:
print('Указанное новое имя изделия уже существует!')

else:
print('Указанное изделие не существует.')

conn.commit()

except Exception as _ex:
print(f"Произошла ошибка при изменении имени изделия: {_ex}")


def get_category_parents(category_name):

if is_category_exists(category_name):
category_name_copy = category_name
try:

cursor.execute("SELECT id FROM category WHERE category_name = ?", (category_name,))
category_id = cursor.fetchone()[0]

# function for recursive search parents
def find_parents(category_id, parents_list):
id_parent = 0

cursor.execute("SELECT EXISTS(SELECT 1 FROM category WHERE id = ?)", (category_id,))
record_exists = cursor.fetchone()[0]

if record_exists:
cursor.execute("SELECT id_parent FROM category WHERE id = ?", (category_id,))
id_parent = cursor.fetchone()[0]

if id_parent == 0:
return

if category_id != 0 and id_parent != 0:
if id_parent != 0:
cursor.execute("SELECT category_name FROM category WHERE id = ?", (id_parent,))
parent_name = cursor.fetchone()
parents_list.append(parent_name)
find_parents(id_parent, parents_list)

parents_list = []
parents_list_res = []

# begin recursive search for parents
find_parents(category_id, parents_list)

for elem in parents_list:
if elem:
parents_list_res.append(elem[0])

if parents_list_res:
print(f'родительские элементы для категории "{category_name_copy}": \n {parents_list_res}')
else:
print(f'У категории "{category_name_copy}" нет родительских элементов')

except Exception as _ex:
print(f"Произошла ошибка при получении списка родителей категории: {_ex}")

else:
print('Категории не существует.')


def print_category_children(category_name, order):

if not is_category_exists(category_name):
print("Такой категории нет.")
return

children_list_res = get_category_children(category_name)
if children_list_res:
if order == 'прямой':
print(f'дочерние элементы для категории "{category_name}": \n {children_list_res}')
elif order == 'обратный':
print(f'дочерние элементы для категории "{category_name}": \n {children_list_res[::-1]}')
else:
print('Такого порядка вывода нет!')
else:
print(f'У категории "{category_name}" нет дочерних элементов')


def get_category_children(category_name):

if is_category_exists(category_name):
try:

cursor.execute("SELECT id FROM category WHERE category_name = ?", (category_name,))
category_id = cursor.fetchone()[0]

# function for recursive search subcategories
def find_children(category_id, children_list):
childrens_id = 0
childrens_id = []

cursor.execute("SELECT COUNT(*) FROM category WHERE id_parent = ?", (category_id,))
record_exists = cursor.fetchall()

if record_exists:
cursor.execute("SELECT id FROM category WHERE id_parent = ?", (category_id,))
childrens_id = cursor.fetchall()

if childrens_id == 0:
return

if category_id != 0 and childrens_id != 0:
for elem in childrens_id:
elem_id = elem[0]

cursor.execute("SELECT category_name FROM category WHERE id = ?", (elem_id,))
child_name = cursor.fetchone()
children_list.append(child_name)

find_children(elem_id, children_list)

children_list = []
children_list_res = []

# begin search subcategories
find_children(category_id, children_list)

for elem in children_list:
if elem:
children_list_res.append(elem[0])

return children_list_res

except Exception as _ex:
print(f"Произошла ошибка при получении списка дочерних категорий: {_ex}")

else:
print('Категории не существует.')



############### added after first review ###############

def print_products_of_category(category_name, order):
products = get_products_of_category(category_name)
if products:
print(f'Изделия для категории "{category_name}":')
print_str = ''

if order == 'прямой':
for prod in products:
print_str += '"' + prod + '"' + ' '
print(print_str)

elif order == 'обратный':
products = products[::-1]
for prod in products:
print_str += '"' + prod + '"' + ' '
print(print_str)
else:
print('Такого порядка вывода нет!')

else:
print(f'У категории "{category_name}" нет изделий')


def get_products_of_category(category_name):
if is_category_exists(category_name):
try:
categories_to_check = get_category_children(category_name)
products = []

if categories_to_check:
for category in categories_to_check:
cursor.execute("SELECT id FROM category WHERE category_name = ?", (category,))
id_of_searched_category = cursor.fetchone()[0]

cursor.execute("SELECT id FROM product WHERE id_category = ?", (id_of_searched_category,))
products_id = cursor.fetchall()


for id in products_id:
cursor.execute("SELECT product_name FROM product WHERE id = ?", (id[0],))
product_to_add = cursor.fetchone()[0]
products.append(product_to_add)


else:
cursor.execute("SELECT id FROM category WHERE category_name = ?", (category_name,))
id_of_searched_category = cursor.fetchone()[0]

cursor.execute("SELECT id FROM product WHERE id_category = ?", (id_of_searched_category,))
products_id = cursor.fetchall()

for id in products_id:
cursor.execute("SELECT product_name FROM product WHERE id = ?", (id[0],))
product_to_add = cursor.fetchone()[0]
products.append(product_to_add)

return products

except Exception as _ex:
print(f"Произошла ошибка при поиске изделия заданной категории: {_ex}")
else:
print('Категории не существует.')


def fill_data_example():

add_category("неопределенные")
add_category("изделия")

##
add_subcategory("изделия", "столы")

add_subcategory("столы", "столы-металл")
add_product("стол_arizone", "столы-металл", 110, 2500)
add_product("стол_garden_story", "столы-металл", 54, 5665)
#
add_subcategory("столы", "столы-дерево")
add_product("стол_эстер", "столы-дерево", 124, 6460)
add_product("стол_кентуки", "столы-дерево", 1340, 2400)

##
add_subcategory("изделия", "стулья")

add_subcategory("стулья", "стулья-пластик")
add_product("стул_rambo", "стулья-пластик", 435, 1580)
add_product("стул_keter", "стулья-пластик", 252, 1300)
#
add_subcategory("стулья", "стулья-металл")
add_product("стул_arizone", "стулья-металл", 245, 3400)
add_product("стул_giardino", "стулья-металл", 25, 2400)

##
add_subcategory("изделия", "кресла")

add_subcategory("кресла", "кресла-кресло_кокон")
add_product("кресло-m-group", "кресла-кресло_кокон", 24, 12000)
add_product("кресло-гамак", "кресла-кресло_кокон", 14, 15500)
#
add_subcategory("кресла", "кресла-двухместное_кресло")
add_product("кресло-gemini_promob", "кресла-двухместное_кресло", 4, 8999)
add_product("кресло-парящая_кровать", "кресла-двухместное_кресло", 54, 9999)



# dropAllTables()

# fill_data_example()




# change_parent_of_subcategory('стулья', 'стулья-пластик') # works (reversed)


# change_parent_of_subcategory('стулья-пластик', 'столы') # works


# change_parent_of_subcategory('стулья-пластик', 'изделия') # works
# change_parent_of_subcategory('изделия', 'стулья-пластик') # works

# change_parent_of_subcategory('неопределенные', 'стулья-пластик') # works

# change_parent_of_subcategory('стулья-пластик', 'стулья-пластик') # works

# change_parent_of_subcategory('стулья-пластик', 'стулья-металл') # works


# change_parent_of_subcategory('стулья') # (even if already root) works

# change_parent_of_subcategory('стулья', 'нет' ) # works


# print_products_of_category('столы', 'прямой')




# cursor.execute("SELECT id_parent FROM category WHERE category_name = ?", ('стулья',))
# id_parent_ = cursor.fetchone()[0]
# print(get_subcategory_parent('стулья'))
# print(f'id_parent_ у стульев - {id_parent_}')




# print_products_of_category('столы', 'прямой')



# print_category_children("стулья", 'прямой')

# print_products_of_category('столы-металл')


# print(get_all_categories())

# print(get_all_products())


# product_update_price('стол_arizone', 5000)

# product_update_quantity('стол_arizone', 100)

# change_product_category('стол_arizone', 'неопределенные')

# delete_product('стол_arizone')

# delete_category('кресла')

# delete_subcategory('кресла-двухместное_кресло')

# change_parent_of_subcategory('кресла-кресло_кокон', 'стулья')

# change_category_name('кресла-кресло_кокон', 'кресла-кресло_кокон_new')

# change_product_name('кресло-парящая_кровать', 'кресло-парящая_кровать_new')

# add_subcategory('кресла-кресло_кокон_new', 'кресла-кресло_кокон_new_child')

# get_category_parents('стулья')

# get_category_children('кресла-кресло_кокон_new_child', 'обратный')

# print('\n')

# print('обратный порядок вывода')
# get_category_children('стулья', 'обратный')

# print('прямой порядок вывода')
# get_category_children('стулья', 'прямой')

# dropAllTables()





#################### dev tests ####################



conn.close()