def add_banned_user():
"""
(None) -> (None)
Function adds banned user from unique list of all users
"""
print("Добавление пользователя в черный список:")
banned_user, err = input_user_by_unique_list_user_id()
if banned_user is None:
return
print(
f"Добавим пользователя с id = {banned_user.uid} {banned_user.last_name} "
f"{banned_user.first_name} в черный список.")
updated_rows, err = vk_db.set_favorite_property_by_user(banned_user.uid, 2)
if err == 0:
print(
f"Пользователь с id = {banned_user.uid} добавлен в черный список. Было обновлено {updated_rows} записей."
)
else:
vk_common.dprint(
2,
f"Ошибка добавления пользователя с id = {banned_user.uid} в черный список."
)
def input_user():
"""
(None) -> object User or None
Function asks user_id or nickname from standard input and gets object User by this user_id
"""
# Input user id
while True:
id_string = input(
"Введите id пользователя ВКонтакте (число=id пользователя или строка=nickname): "
).strip()
# id_string = '171691064'
# id_string = '5521318'
user, msg, err = get_user_by_id(id_string)
if err == 0:
break
else:
vk_common.dprint(2, vk_common.func_name(), user, err, msg)
if err == 5:
break
else:
continue
return user, err, msg
def drop_db():
"""
(cursor link) -> None
Function drops all tables
"""
is_drop = 0
is_exist = 0
for table_idx in (0, 4, 3, 2, 1):
result = is_exists_table(TABLES_NAMES[table_idx])
if result:
is_exist += 1
rows, err = drop_table(TABLES_NAMES[table_idx])
if err == 0:
is_drop += 1
vk_common.dprint(2, vk_common.func_name(),
f"Существовали {is_exist} таблиц.")
vk_common.dprint(2, vk_common.func_name(), f"Удалили {is_drop} таблиц.")
if is_drop != is_exist:
return -1
else:
return is_drop
def add_favorite_user():
"""
(None) -> (None)
Function adds favorite user from unique list of all users
"""
print("Добавление пользователя в список избранных:")
favorite_user, err = input_user_by_unique_list_user_id()
if favorite_user is None:
return
print(
f"Добавим пользователя с id = {favorite_user.uid} {favorite_user.last_name} "
f"{favorite_user.first_name} в список избранных.")
updated_rows, err = vk_db.set_favorite_property_by_user(
favorite_user.uid, 1)
if err == 0:
print(
f"Признак избранности установлен. Было обновлено {updated_rows} записей."
)
else:
vk_common.dprint(
2, "Ошибка установки признака избранности у пользователя.")
def wrapper(*args, **kwargs):
conn = None
curs = None
err = (None, -1)
try:
conn = psycopg2.connect(CONNECT_STRING)
conn.autocommit = False
curs = conn.cursor()
# Function for select, insert, update request
function_to_decorate(curs, *args, **kwargs)
try:
result_records = curs.fetchall()
err = (result_records, 0)
except psycopg2.ProgrammingError:
err = (None, 0)
except (Exception, psycopg2.DatabaseError) as error:
vk_common.dprint(2, error)
if error.find(" не существует") == -1 and error.find(
"ОШИБКА: отношение ") == -1:
vk_common.dprint(
2,
"Error in transaction Reverting all other operations of a transaction ",
error)
if conn is not None:
conn.rollback()
err = (None, -1)
finally:
if conn is not None:
conn.commit()
curs.close()
conn.close()
return err
def get_user_by_id(id_string):
"""
(string) -> (User or None, string, int)
Function gets object User by users's id string from VK
"""
vk_common.dprint(2, vk_common.func_name(),
f"Входные данные: id_string = {id_string}")
try:
int(id_string)
id_string = f"id{id_string}"
except ValueError as error:
vk_common.dprint(2, vk_common.func_name(), error)
if vk_common.test_id(id_string):
user = vk_user.User()
user.assign_by_nickname(id_string)
if user.error["error"] != 0:
if user.error["error"] == 113:
print(
f"Аккаунт ВК с id = \"{id_string}\" не определен в системе."
)
else:
print(
f"Возникла ошибка {user.error['error']}: {user.error['msg']}."
)
return None, user.error['msg'], user.error["error"]
else:
return user, "", 0
else:
print("Введенная строка не может быть идентификатором пользователя.")
return None, "", -1
def add_user_photos(curs, user):
"""
(cursor link, object User) -> integer
Function add user's photos to table of photos
"""
if not hasattr(user, 'photos'):
vk_common.dprint(2, vk_common.func_name(),
"Не определен атрибут photos.")
return
vk_common.dprint(2, vk_common.func_name(), "Входные данные user.photos: ",
user.photos)
rec_ids = list()
for number, photo in enumerate(user.photos, 1):
item_id = photo[0]
image_file_path = photo[1]
sql_text = f"insert into {TABLES_NAMES[0]} (user_id, top_id, image_file_path, item_id) " \
f"values (%s, %s, %s, %s) returning id"
curs.execute(sql_text, (user.uid, number, image_file_path, item_id))
rec_id = curs.fetchone()[0]
rec_ids.append(rec_id)
return rec_ids
def get_user_id_by_old_searches(user_id):
"""
(int) -> (list, int)
Function gets list of user_ids from database are which was written earlier to database
"""
rows, err = vk_db.get_count_rows_of_table(vk_db.TABLES_NAMES[4])
if err != 0:
value = (None, err)
return value
else:
if rows is not None:
count_rows = rows[0][0]
else:
count_rows = 0
user_id_old = list()
if count_rows > 0:
rows, err = vk_db.get_users_by_old_searches(user_id)
if err != 0:
vk_common.dprint(2, err)
value = (None, err)
return value
else:
for row in rows:
user_id_old.append(row[0])
return user_id_old, 0
else:
return user_id_old, 0
def wrapper(*args, **kwargs):
conn = None
curs = None
err = (None, 0)
try:
conn = psycopg2.connect(CONNECT_STRING)
conn.autocommit = False
curs = conn.cursor()
# Function for select, insert, update request
value = function_to_decorate(curs, *args, **kwargs)
err = (value, 0)
except (Exception, psycopg2.DatabaseError) as error:
vk_common.dprint(2, error)
cnt = vk_common.is_common_by_text(
'значение ключа нарушает ограничение уникальности', error)
if cnt == 0:
vk_common.dprint(
2,
"Error in transaction Reverting all other operations of a transaction ",
error)
if conn is not None:
conn.rollback()
err = (None, -1)
else:
err = (None, -2)
finally:
if conn is not None:
conn.commit()
curs.close()
conn.close()
return err
def get_common_groups(self, other):
"""
(object User) -> tuple(int, string, list or None)
Function gets common groups in list of id groups
"""
if not isinstance(other, User):
vk_common.dprint(
1,
f"Входные данные типа {type(other)}, а ожидается тип {type(self)}"
)
raise ValueError
# Conversions to sets from lists
error, msg, id_groups = self.get_id_groups()
if error != 0:
value = (error, msg, None)
return value
error, msg, other_id_groups = other.get_id_groups()
if error != 0:
value = (error, msg, None)
return value
self_groups = set(id_groups)
other_groups = set(other_id_groups)
# Getting common friends equals intersection of sets
common_groups_list = list(self_groups.intersection(other_groups))
value = (0, "", common_groups_list)
return value
def right(self, event, number):
"""
(string, int) -> (int)
Function describes pressing on button ">>" on the frame (event = press on button)
"""
if not hasattr(self, 'top_images'):
vk_common.dprint(1, "Не определен атрибут \"top_images\".")
return -1
if len(self.top_images) < 1:
vk_common.dprint(1, "Массив изображений пуст.")
return -1
while True:
self.top_id += 1
if self.top_id > 3:
self.top_id = 1
err = self.load_image()
if err == 0:
break
return 0
def execute_mode_divide_search_by_month():
"""
(None) -> (None)
Function execute mode divide search by month of parameter application MODE_DIVIDE_SEARCH_BY_MONTH
which affects to amount users which we get from VK
"""
while True:
mode = int(
input(
"Включить или выключить режим разделения запроса по 12 месяцам(0=выкл или 1=вкл)): "
).strip())
if mode not in (0, 1):
print("Параметр может принимать значение 0 или 1.")
continue
else:
vk_search.MODE_DIVIDE_SEARCH_BY_MONTH = mode
vk_common.dprint(
2,
f"Параметр MODE_DIVIDE_SEARCH_BY_MONTH изменён и теперь равен "
f"{vk_search.MODE_DIVIDE_SEARCH_BY_MONTH}.")
break
def drop_table(curs, table_name):
"""
(cursor link) -> None
Function drops table by table name
"""
sql_text = f"""DROP TABLE if exists {table_name}"""
vk_common.dprint(2, vk_common.func_name(), f"Текст запроса: {sql_text}")
curs.execute(sql_text)
def assign_by_user_info(self, user_info):
"""
(dict) -> None
Function set some parameters of object User by information about user
"""
# id,first_name,last_name,bdate,deactivated,is_closed,interests,books,movies,music,last_seen,personal,relation,sex,city
vk_common.dprint(2, "user_info = ", user_info)
self.set_attrs(user_info)
def __init__(self, users):
if len(users) < 1:
vk_common.dprint(
1, "Ошибка с входными параметрами: массив пользователей пуст.")
self.users = users
vk_common.dprint(2, vk_common.func_name(),
"Список пользователей при входе: ", self.users)
self.top_id = 1
self.label = None
self.user_id = None
self.item_ids = None
self.top_images = None
self.root = None
self.f_source = None
self.f_control = None
self.f_image = None
def load_image(self):
"""
(None) -> (int)
Function loads images from files from the disk to object label
"""
if not hasattr(self, 'user_id'):
vk_common.dprint(1, "Не определен атрибут user_id.")
return -1
if not hasattr(self, 'top_id'):
vk_common.dprint(1, "Не определен атрибут top_id.")
return -1
if self.top_id not in (1, 2, 3):
vk_common.dprint(1, "Атрибут top_id <> 1,2,3.")
return -1
err = -1
try:
vk_common.mk_dir(vk_common.DIR_IMAGES)
file_path = f"{vk_common.DIR_IMAGES}{self.user_id}_{self.top_id}.jpg"
vk_common.dprint(2, vk_common.func_name(),
f"Загружаем фото на форму из файла {file_path}.")
img = Image.open(file_path)
render = ImageTk.PhotoImage(img)
if hasattr(self, 'label'):
if self.label is not None:
self.label.destroy()
self.label = Label(self.f_image, image=render)
self.label.image = render
self.label.pack()
err = 0
except FileNotFoundError as error:
vk_common.dprint(2, vk_common.func_name(), "Возникло исключение: ",
error)
err = -2
finally:
return err
def get_attr_value(fields, name_attr):
"""
(dict, string) -> dict
Function gets value of attribute by dict from vk and by name this attribute
"""
f = fields.get(name_attr)
vk_common.dprint(2, vk_common.func_name(), f"Тип переменной = ", type(f))
if f is not None:
if isinstance(f, str):
if len(f) <= 0:
f = None
return f
def search_by(search_info):
"""
(dict) -> (integer, string, list of objects or None)
Function executes search users by search parameters
"""
params_here = vk_common.params.copy()
params_here.update(search_info)
vk_common.dprint(2, vk_common.func_name(), "Параметры поиска: ",
params_here)
value = vk_common.request_get("https://api.vk.com/method/users.search",
params_here, vk_common.func_name())
vk_common.dprint(2, vk_common.func_name(), "Результат поиска: ", value)
return value
def get_common_friends(self, other):
"""
(object User) -> tuple(int, string, list or None)
Function gets common friends in list of objects of User
"""
if not isinstance(other, vk_user.User):
vk_common.dprint(
1,
f"Входные данные типа {type(other)}, а ожидается тип {type(self)}"
)
raise ValueError
if other.friends is None:
value = (-1, "Список друзей у переданного пользователя пуст.",
None)
return value
other_friends = set(other.friends)
for user in self.users:
if user.friends is None:
vk_common.dprint(
2,
f"Список друзей у пользователя пуст. user_id = {user.uid}")
user.common_friends = None
user.cnt_common_friends = 0
continue
user_friends = set(user.friends)
# Getting common friends equals intersection of sets
common_friends_list = list(
user_friends.intersection(other_friends))
user.common_friends = common_friends_list
user.cnt_common_friends = len(common_friends_list)
value = (0, "", None)
return value
def re_create_db():
"""
(None) -> None
Function recreated all tables
"""
result = drop_db()
vk_common.dprint(2, vk_common.func_name(),
f" Результат работы drop_db равен {result}.")
if result == -1:
return "", -1
msg, err = create_db()
vk_common.dprint(2, vk_common.func_name(),
f"Результат работы create_db равен ({msg} {err})")
return msg, err
def execute_app(self):
"""
(None) -> (None)
Function describes execute gdi interface for liking or disliking photos of users
"""
self.root = Tk()
self.root.geometry(
f"{vk_common.MAX_IMAGE_WIDTH}x{vk_common.MAX_IMAGE_HEIGHT}")
self.root.title("Лайкер")
self.f_source = Frame(self.root)
self.f_source.pack(side=TOP)
self.f_control = Frame(self.root)
self.f_control.pack(side=TOP)
self.f_image = Frame(self.root)
self.f_image.pack(side=BOTTOM)
vk_common.dprint(2, vk_common.func_name(),
"Список пользователей при входе: ", self.users)
for number, user in enumerate(self.users, 1):
set_button(self.f_source, str(number), self.select, number)
set_button(self.f_control, "Лайкнуть", self.like, 1)
set_button(self.f_control, "ДизЛайкнуть", self.dislike, 2)
set_button(self.f_control, "<<", self.left, 3)
set_button(self.f_control, ">>", self.right, 4)
self.top_id = 1
self.select_user(1)
self.root.focus_set()
self.root.wm_state('zoomed')
self.root.call('wm', 'attributes', '.', '-topmost', '1')
self.root.mainloop()
sleep(1 / 3)
self.root.quit()
def get_common_friends(self, other):
"""
(object User) -> tuple(int, string, list or None)
Function gets common friends in list of objects of User
"""
if not isinstance(other, User):
vk_common.dprint(
1,
f"Входные данные типа {type(other)}, а ожидается тип {type(self)}"
)
raise ValueError
# Conversions to sets from lists
error, msg, id_friends = self.get_id_friends()
if error != 0:
value = (error, msg, None)
return value
error, msg, other_id_friends = other.get_id_friends()
if error != 0:
value = (error, msg, None)
return value
self_friends = set(id_friends)
other_friends = set(other_id_friends)
# Getting common friends equals intersection of sets
common_friends_list = list(self_friends.intersection(other_friends))
common_friends = []
for user_id in common_friends_list:
user_friend = User()
user_friend.assign_by_nickname(user_id)
common_friends.append(user_friend)
value = (0, "", common_friends)
return value
def set_favorite_property_by_user(curs, user_id, value):
"""
(cursor link, int, int) -> int or None
Function sets favorite user
"""
if value not in (1, 2):
vk_common.dprint(
1,
"Значение поля favorite может принимать значения 1-избранный 2-черный список"
)
return
sql_text = f"UPDATE {TABLES_NAMES[2]} SET favorite = %s WHERE id = %s returning id"
curs.execute(sql_text, (value, user_id))
updated_rows = curs.rowcount
return updated_rows
def get_top_users_by_search(search, count_top):
"""
(object Search, int) -> (list of objects User or None, int)
Function gets top-list users from results of object search (executes necessary sorting of objects beforehand)
"""
# user_id_old = vk_db.get_user_id_by_old_searches(user.uid)
user_list = list()
for index, u in enumerate(search.results):
if u is not None:
# if u.uid not in user_id_old:
vk_common.dprint(
2,
f"user_id = {u.uid}, кол-во общ. друзей = {u.cnt_common_friends}, "
f"кол-во общ. групп = {u.cnt_common_groups}")
user_list.append(
(index, u.age, u.age_difference, u.cnt_common_friends,
u.cnt_common_groups, u.cnt_common_interests,
u.cnt_common_music, u.cnt_common_books))
vk_common.dprint(2, f"Получили список пользователей: {user_list}")
if len(user_list) > 0:
vk_common.dprint(2, f"Список пользователей до сортировки: {user_list}")
# u.age_difference asc, u.cnt_common_friends desc, u.cnt_common_groups desc, u.cnt_common_interests desc,
# u.cnt_common_music desc, u.cnt_common_books desc
user_list.sort(key=lambda x: (x[2], -x[3], -x[4], -x[5], -x[6], -x[7]))
vk_common.dprint(
2, f"Список пользователей после сортировки: {user_list}")
top_users = list()
for number, u in enumerate(user_list, 1):
if number > count_top:
break
top_users.append(search.results[u[0]])
search.top_results = top_users
value = (top_users, 0)
else:
search.top_results = None
value = (user_list, 0)
return value
def execute_mode_count_rec_by_one_request():
"""
(None) -> (None)
Function execute mode input new value of parameter application COUNT_REC_BY_ONE_REQUEST
which affects to speed and result
"""
while True:
cnt_users = int(
input(
"Введите кол-во записей получаемых одним запросом(1..1000)): "
).strip())
if cnt_users < 1 or cnt_users > 1000:
print("Параметр должен быть в диапазоне от 1 до 1000.")
continue
else:
vk_search.COUNT_REC_BY_ONE_REQUEST = cnt_users
vk_common.dprint(
2, f"Параметр COUNT_REC_BY_ONE_REQUEST изменён и теперь равен "
f"{vk_search.COUNT_REC_BY_ONE_REQUEST}.")
break
def input_user_by_unique_list_user_id():
"""
(None) -> (object User, int)
Function select user from unique list of all users from database
"""
unique_users, err = vk_db.get_unique_users()
if err != 0:
vk_common.dprint(2, "Ошибка при добавлении избранного пользователя",
unique_users, err)
return None, -1
else:
if len(unique_users) > 0:
print(unique_users)
else:
print("Список всех пользователей пуст.")
return None, 0
txt = "Список всех пользователей:\n"
for number, user in enumerate(unique_users, 1):
txt += f"{number}. Пользователь c id = {user[0]}, {user[1]} {user[2]}\n"
number = int(
input(
"Введите порядковый номер соответствующий id пользователя из списка:\n"
+ txt).strip())
vk_common.dprint(2, f"unique_users = {unique_users}")
user_id_need = unique_users[number - 1][0]
vk_common.dprint(2, f"user_id_need = {user_id_need}")
user_need, msg, err = get_user_by_id(user_id_need)
if err != 0:
print(
f"Ошибка: В системе ВК не определен пользователь с id = {user_id_need}"
)
return None, -1
else:
vk_common.dprint(
2,
f"В системе ВК определен пользователь {user_need.last_name} {user_need.first_name} "
f"с id = {user_need.uid}")
return user_need, 0
def select_user(self, number):
"""
(int) -> (int)
Function describes pressing on any button on the frame
"""
if len(self.users) < 1:
vk_common.dprint(1, "Массив пользователей пуст.")
return -1
vk_common.dprint(2, vk_common.func_name(),
"Список пользователей при входе: ", self.users)
self.user_id = self.users[number - 1][0]
self.item_ids = self.users[number - 1][1]
vk_common.dprint(2, f"Выбран пользователь с id = {self.user_id}")
rows, err = vk_db.get_photo_info_by_user_id(self.user_id)
if err != 0:
vk_common.dprint(1, "Ошибка получения имен изображений.")
return -2
vk_common.dprint(2, rows)
self.top_images = rows
err = self.load_image()
if err != 0:
vk_common.dprint(1,
"Ошибка при загрузке изображений из БД на форму")
return -2
return 0
def dislike(self, event, number):
"""
(string, int) -> (None)
Function describes pressing on button "DISLIKE" on the frame (event = press on button)
"""
if not hasattr(self, 'user_id') or not hasattr(self, 'top_id'):
vk_common.dprint(2, vk_common.func_name(),
f"Не заданы атрибуты user_id = или top_id.")
return
item_id = self.item_ids[self.top_id - 1]
if item_id is None:
vk_common.dprint(2, vk_common.func_name(),
f"Атрибут item_id = None.")
return
else:
vk_common.dprint(2, vk_common.func_name(),
f"number = {number}; item_id = {item_id}")
vk_common.dprint(2, vk_common.func_name(),
f"number = {number}; item_id = {item_id}")
vk_common.dprint(
1, f"имя файла с фото = \"{self.user_id}_{self.top_id}\"; "
f"ссылка = https://vk.com/id{self.user_id}")
err, msg, likes = vk_common.dislike_photo(self.user_id, item_id)
if err != 0:
mb.showinfo(
"Информация",
f"Не смогли убрать лайк у фото пользователя с id = {self.user_id}."
)
vk_common.dprint(2, "Не смогли убрать лайк.")
return
mb.showinfo("Информация",
f"Убрали лайк у фото пользователя с id = {self.user_id}.")
vk_common.dprint(
2, f"Убрали лайк: owner_id = {self.user_id}; item_id = {item_id}")
def add_search(search):
"""
(object Search) -> ((int, list, list) or None, int)
Function adds object of search to database fully
"""
# Get list of all users from DB
rows, err = get_all_cities()
if err != 0:
vk_common.dprint(1, "Ошибка при получении списка всех городов.")
return None, -1
city_ids = set()
for row in rows:
city_ids.add(row[0])
vk_common.dprint(2, "Список всех городов: ", city_ids)
# Get list of users which we want to add
city_add_ids = set()
for user in search.results:
city_add_ids.add(user.city_id)
vk_common.dprint(2, "Список добавляемых городов: ", city_add_ids)
city_ids_intersect = city_ids.intersection(city_add_ids)
vk_common.dprint(2, "Список пересечения: (города) ", city_ids_intersect)
conn = None
err = (None, -1)
try:
conn = psycopg2.connect(CONNECT_STRING)
conn.autocommit = False
with conn.cursor() as curs:
try:
sql_text = f"insert into {TABLES_NAMES[3]} (user_id, age_from, age_to, sex) values (%s, %s, %s, %s) " \
f"returning id"
curs.execute(sql_text, (search.user_id, search.age_from,
search.age_to, search.sex))
search_id = curs.fetchone()[0]
except (Exception, psycopg2.DatabaseError) as error:
vk_common.dprint(
1, f"Не могу добавить запись в таблицу {TABLES_NAMES[3]}",
error)
vk_common.dprint(2, "Добавили search_id: ", search_id)
curs.execute("SAVEPOINT city_successfully")
city_ids = []
for user in search.results:
if user.city_id in city_ids_intersect:
continue
vk_common.dprint(
2,
f"-------------->> Смотрим на очередной city_id = {user.city_id}"
)
try:
sql_text = f"insert into {TABLES_NAMES[1]} (id, name) values (%s, %s) returning id"
curs.execute(sql_text, (user.city_id, user.city_title))
rec_id = curs.fetchone()[0]
city_ids.append(rec_id)
curs.execute("SAVEPOINT city_successfully")
vk_common.dprint(
2,
f"-------------->> Добавили город корректно city_id = {user.city_id}"
)
# except (Exception, psycopg2.DatabaseError, psycopg2.errors.UniqueViolation) as error:
except (Exception, psycopg2.DatabaseError) as error:
vk_common.dprint(2, "error type: ", type(error))
vk_common.dprint(2, "error args: ", error.args)
str_err = vk_common.is_common_by_text(
"повторяющееся значение ключа нарушает ограничение "
"уникальности", error.args[0])
vk_common.dprint(2, "str_err = ", str_err)
if str_err > 0:
vk_common.dprint(
1,
f"Не могу добавить запись в таблицу {TABLES_NAMES[1]}",
error)
curs.execute("ROLLBACK TO SAVEPOINT city_successfully")
vk_common.dprint(
2,
f"-------------->> Откат назд после добавления city_id = {user.city_id}"
)
curs.execute("SAVEPOINT user_successfully")
user_ids = []
for user in search.results:
# if user.uid in user_ids_intersect:
# continue
vk_common.dprint(
2,
f"-------------->> Смотрим на очередной user_id = {user.uid}"
)
try:
sql_text = f"insert into {TABLES_NAMES[2]} (id, first_name, last_name, age, interests, books, " \
f"music, sex, city_id) values (%s, %s, %s, %s, %s, %s, %s, %s, %s) returning id"
curs.execute(sql_text,
(user.uid, user.first_name, user.last_name,
user.age, user.interests, user.books,
user.music, user.sex, user.city_id))
rec_id = curs.fetchone()[0]
user_ids.append(rec_id)
curs.execute("SAVEPOINT user_successfully")
vk_common.dprint(
2,
f"-------------->> Добавили пользователя корректно user_id = {user.uid}"
)
# except (Exception, psycopg2.DatabaseError, psycopg2.errors.UniqueViolation) as error:
except (Exception, psycopg2.DatabaseError) as error:
vk_common.dprint(2, "error type: ", type(error))
vk_common.dprint(2, "error args: ", error.args)
str_err = vk_common.is_common_by_text(
"повторяющееся значение ключа нарушает ограничение "
"уникальности", error.args[0])
vk_common.dprint(2, "str_err = ", str_err)
if str_err > 0:
vk_common.dprint(
1,
f"Не могу добавить запись в таблицу {TABLES_NAMES[2]}",
error)
curs.execute("ROLLBACK TO SAVEPOINT user_successfully")
vk_common.dprint(
2,
f"-------------->> Откат назд после добавления user_id = {user.uid}"
)
vk_common.dprint(2, "Добавили пользователей: ", user_ids)
try:
result_ids = []
for user in search.results:
sql_text = f"insert into {TABLES_NAMES[4]} (search_id, user_id, cnt_common_friends, " \
f"cnt_common_groups, cnt_common_interests, cnt_common_books, cnt_common_music) values " \
f"(%s, %s, %s, %s, %s, %s, %s) returning id"
curs.execute(
sql_text,
(search_id, user.uid, user.cnt_common_friends,
user.cnt_common_groups, user.cnt_common_interests,
user.cnt_common_books, user.cnt_common_music))
result_id = curs.fetchone()[0]
result_ids.append(result_id)
except (Exception, psycopg2.DatabaseError) as error:
vk_common.dprint(
1, f"Не могу добавить запись в таблицу {TABLES_NAMES[2]}",
error)
vk_common.dprint(2, "Добавили результаты поиска: ", result_ids)
err = ((search_id, user_ids, result_ids), 0)
vk_common.dprint(2, "вернем err = ", err)
except (Exception, psycopg2.DatabaseError) as error:
vk_common.dprint(1, "Общая ошибка во всей транзакции: ", error)
if error.find(" не существует") == -1 and error.find(
"ОШИБКА: отношение ") == -1:
vk_common.dprint(
2,
"Error in transaction Reverting all other operations of a transaction ",
error)
if conn is not None:
conn.rollback()
err = (None, -1)
finally:
if conn is not None:
conn.commit()
conn.close()
return err
def create_db(curs):
"""
(cursor link) -> None
Function creates all tables
"""
# "id,name"
sql_text = f"""CREATE TABLE if not exists {TABLES_NAMES[1]} (
id numeric(4) NOT NULL PRIMARY KEY,
name varchar(100));
"""
curs.execute(sql_text)
vk_common.dprint(2, vk_common.func_name(),
f"Создали таблицу {TABLES_NAMES[1]}")
# "id,first_name,last_name,age,interests,books,music,sex,city_id,favorite"
sql_text = f"""CREATE TABLE if not exists {TABLES_NAMES[2]} (
id numeric(10) NOT NULL PRIMARY KEY,
first_name varchar(50),
last_name varchar(50),
age numeric(3),
interests varchar(3000),
books varchar(3000),
music varchar(3000),
sex numeric(1),
city_id integer references {TABLES_NAMES[1]}(id),
favorite numeric(1));
"""
curs.execute(sql_text)
vk_common.dprint(2, vk_common.func_name(),
f"Создали таблицу {TABLES_NAMES[2]}")
# "id,user_id,age_from,age_to,sex"
sql_text = f"""CREATE TABLE if not exists {TABLES_NAMES[3]} (
id serial PRIMARY KEY,
user_id integer references {TABLES_NAMES[2]}(id),
age_from numeric(3),
age_to numeric(3),
sex numeric(1));
"""
curs.execute(sql_text)
vk_common.dprint(2, vk_common.func_name(),
f"Создали таблицу {TABLES_NAMES[3]}")
# "id,search_id,user_id,cnt_common_friends,cnt_common_groups,cnt_common_interests,cnt_common_books,cnt_common_music"
sql_text = f"""CREATE TABLE if not exists {TABLES_NAMES[4]} (
id serial PRIMARY KEY,
search_id integer references {TABLES_NAMES[3]}(id),
user_id integer references {TABLES_NAMES[2]}(id),
cnt_common_friends numeric(4),
cnt_common_groups numeric(4),
cnt_common_interests numeric(4),
cnt_common_books numeric(4),
cnt_common_music numeric(4));
"""
curs.execute(sql_text)
vk_common.dprint(2, vk_common.func_name(),
f"Создали таблицу {TABLES_NAMES[4]}")
# "id,user_id,top_id,image_file_path"
sql_text = f"""CREATE TABLE if not exists {TABLES_NAMES[0]} (
id serial PRIMARY KEY,
user_id integer references {TABLES_NAMES[2]}(id),
top_id numeric(2),
image_file_path varchar(100),
item_id integer);
"""
curs.execute(sql_text)
vk_common.dprint(2, vk_common.func_name(),
f"Создали таблицу {TABLES_NAMES[0]}")
