def change_password(data):
"""
Функция получает json с id пользователя, старым паролем и новым.
Проверяет элементы data, None или нет.
Покдлючается к базе данных с помощью функции db_connect(), получает хеш пароля в базе по id.
Если хеш от old_password==паролю в базе, то записывает в базу хеш new_password.
Если все успешно, то функция вернет {names.ANSWER: 'Succes'}, если не верный пароль - {names.ANSWER: 'Wrong password'}
"""
try:
for i in data:
if data[i] is None:
logging.info('Incorrect parameter ' + i + ' - None')
data[i] = "Empty"
return {names.ANSWER: names.ERROR, names.DATA: data}
except:
logging.error('Fatal error: check data is None')
return {names.ANSWER: names.ERROR, names.DATA: data}
try:
if gs.check_id(data[names.ID_USER]) == False:
return {names.ANSWER: "Id not found", names.DATA: data}
except:
logging.error('Fatal error: check id')
return {names.ANSWER: names.ERROR, names.DATA: data}
else:
try:
sql = "SELECT password FROM auth where id_user = '******'".format(
data[names.ID_USER])
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
else:
try:
password_hash = hashlib.md5()
password_hash.update(data['Old_password'].encode())
data['Old_password'] = password_hash.hexdigest()
if data['Old_password'] == result[0]["password"]:
password_hash = hashlib.md5()
password_hash.update(data['New_password'].encode())
data['New_password'] = password_hash.hexdigest()
sql = "UPDATE auth SET password='******' WHERE id_user='******'".format(
data["New_password"], data[names.ID_USER])
gs.SqlQuery(sql)
return {names.ANSWER: names.SUCCESS}
else:
return {names.ANSWER: "Wrong password"}
except:
logging.error('Fatal error: Password comparison')
return {names.ANSWER: names.ERROR}
def all_event(id_user, count):
"""
Метод возвращает 10 событий, начиная с заданного номера
:param id_user: int id пользователя
:param count: int номер события, с которого начинать вывод
:return: {names.ANSWER: names.SUCCESS, names.DATA: result}
"""
try:
sql = """with
events as (
select id_event
, Name
, Status
, Date_start
, Date_end
, case when (Date_end - Date_start) < interval '0 hours' then null else timestamp '2001-01-01 00:00' + (Date_end - Date_start) - interval '2001 year' end::text as interval
, case when (select 1 from participation where id_user = {id_user} and id_event = ev.id_event) is not null then True else False end as participation
, (select count(*) from participation where id_event = ev.id_event) as count
from Event ev
order by status desc, date_start, date_end
limit 10
offset {count}
)
table events""".format(count=count, id_user=id_user)
#print(sql)
if isinstance(count, int) and count >= 0:
result = gs.SqlQuery(sql)
print(result)
else:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def user_cabinet(data):
"""
Функция подключается к базе данных,находит пользователя по id, который был получен на вход.
Проверяет, что id не пустой. Возвращает json с данными о пользователе.
"""
try:
if data[names.ID_USER] is None:
logging.info('Incorrect parameter id - None')
data[names.ID_USER] = "Empty"
return {names.ANSWER: names.ERROR, names.DATA: data}
except:
logging.error('Fatal error: param id')
return {names.ANSWER: names.ERROR, names.DATA: data}
try:
if gs.check_id(data[names.ID_USER]) == False:
return {names.ANSWER: "Id not found", names.DATA: data}
except:
logging.error('Fatal error: check id')
return {names.ANSWER: names.ERROR, names.DATA: data}
try:
sql = "SELECT Name, City, Sex, Email, Logo, Educational FROM users " \
"where id_user = '******'".format(data[names.ID_USER])
#print(sql)
result = gs.SqlQuery(sql)
return {names.ANSWER: names.SUCCESS, names.DATA: result}
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
def auth_user(user_data):
"""
Метод авторизирует пользователя, присваивая ему UUID сессии
:param user_data: dict хранит информацию о пользователе
:return: UUID сессии
"""
password_hash = hashlib.md5()
password_hash.update(user_data[names.PASSWORD].encode())
user_data[names.PASSWORD] = password_hash.hexdigest()
try:
sql = "SELECT id_user FROM Auth WHERE Login = '******' and Password = '******'".format(
user_data[names.LOGIN], user_data[names.PASSWORD])
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: "Ошибка запроса к базе данных"}
try:
if len(result) == 0:
return {
names.ANSWER: names.WARNING,
names.DATA: "Данного пользователя нет в базе данных"
}
except:
return {
names.ANSWER: names.WARNING,
names.DATA: "Логин или пароль не правильные"
}
answer = input_session_table(result[0].get(names.ID_USER))
if answer.get(names.ANSWER) is not names.SUCCESS:
return {
names.ANSWER: names.WARNING,
names.DATA: "Ошибка запроса к базе данных. Неудача"
}
return answer
def get_task_event(data):
sql = """SELECT ID_Task
, Task_name
, Task_category
, Task_point
, Task_description
, Task_hint
, Task_link
, case
when exists(
select *
from task_acc
where id_event = {id_event}
and id_user = {id_user}
and id_task = t.id_task
) then True
else False
end as close
FROM task t
WHERE id_event = {id_event}
and (select status from event where id_event = {id_event}) = 1
ORDER BY Task_category
, Task_point
""".format(id_user=data['id_user'], id_event=data['id_event'])
#print(sql)
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR_CONNECT_DATABASE}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def input_auth_table(user_data):
"""
Метод начинает цепочку регистрации в бд
Заносится изменение в таблицу auth
:param user_data: dict данные пользователя
:return: UUID сессии
"""
connect, current_connect = db_connect_new()
if connect == -1:
return {
names.ANSWER: names.WARNING,
names.DATA: "Ошибка доступа к базе данных, повторить позже"
}
password_hash = hashlib.md5()
password_hash.update(user_data[names.PASSWORD].encode())
user_data[names.PASSWORD] = password_hash.hexdigest()
sql = "INSERT INTO Auth (login, password)" \
" VALUES (\'{Login}\',\'{Password}\') RETURNING id_user".format(
Login=user_data.get(names.LOGIN),
Password=user_data.get(names.PASSWORD))
try:
id_user = gs.SqlQuery(sql)[0]['id_user']
except:
logging.error(
'error: Ошибка запроса к базе данных. Возможно такой пользователь уже есть'
)
return {
names.ANSWER:
names.WARNING,
names.DATA:
"Ошибка запроса к базе данных. Возможно такой пользователь уже есть"
}
return input_access_table(id_user, user_data, connect, current_connect)
def session():
sql = """select * from Session"""
result = Query(sql)
for i in result:
sql = '''INSERT INTO session
VALUES ({session},'{id_user}','{uuid}')'''.format(session=i['Session'], id_user=i['User'], uuid=i['UUID'])
print(sql)
gs.SqlQuery(sql)
def Event():
sql = """select * from Event"""
result = Query(sql)
for i in result:
sql = '''INSERT INTO event
VALUES ({id_event},'{name}','{description}','1','1',now(),now(),now(),now())'''.format(id_event=i['Event'], name=i[names.NAME], description=i['Description'])
print(sql)
gs.SqlQuery(sql)
def auth():
sql = """select * from Access"""
result = Query(sql)
for i in result:
sql = '''INSERT INTO access
VALUES ({id_user},{access})'''.format(id_user=i['User'], access=i['Access'])
print(sql)
gs.SqlQuery(sql)
def auth():
sql = """select * from Auth"""
result = Query(sql)
for i in result:
sql = '''INSERT INTO auth(id_user, login, password)
VALUES ({id_user},\'{login}\',\'{password}\')'''.format(id_user=i['User'], login=i[names.LOGIN], password=i[names.PASSWORD])
print(sql)
gs.SqlQuery(sql)
def get_news_order_by_data():
sql = "SELECT * FROM News n ORDER BY n.Date"
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR_CONNECT_DATABASE}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def task():
sql = """select * from task"""
result = Query(sql)
for i in result:
sql = '''INSERT INTO task
VALUES ({ID_Task},'{Task_category}','{Task_name}','{Task_flag}',
'{Task_description}','{Task_point}','{Task_hint}','{Task_solve}','{Task_link}',{Status}, {Public_status}, {id_Event})'''.format(**i)
print(sql)
gs.SqlQuery(sql)
def task_acc():
sql = """select * from task_acc"""
result = Query(sql)
for i in result:
sql = '''INSERT INTO task_acc
VALUES ({id},{id_task},{id_user},{id_event},
{point},'{time}')'''.format(**i)
print(sql)
gs.SqlQuery(sql)
def get_news_by_id_user(id_user):
sql = "SELECT * FROM News n WHERE n.id_user = {id_user} ORDER BY n.Date"\
.format(id_user=id_user)
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR_CONNECT_DATABASE}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def get_task_event_category(event, task_category):
sql = "SELECT id_task, task_name, task_category, event FROM task WHERE event={} AND task_category={}".format(
event, task_category)
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def user():
sql = """select * from Users"""
result = Query(sql)
for i in result:
print(i)
sql = '''INSERT INTO users
VALUES ({User},'{Name}','{Surname}','{Email}',
'{Sex}','{City}','{Educational}','{Logo}')'''.format(**i)
print(sql)
gs.SqlQuery(sql)
def get_task_event_name(event, task_name):
sql = "SELECT ID_Task, Task_name, Task_category, Task_description FROM task WHERE event={} AND ID_Task={}".format(
event, task_name)
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def check_id(id_user):
"""
Передаем функции искомый id.
Возвращает True если id есть, False если id нет
"""
try:
sql = "select exists(select 1 from users where id_user = {})".format(
id_user)
return gs.SqlQuery(sql).get('exists', False)
except:
logging.error('Fatal error: check id')
return {names.ANSWER: names.ERROR}
def page_event(data):
sql = "SELECT Name, Description, logo, Date_start, Date_end, Date_continue, Status FROM event WHERE id_event = {}".format(data["id_event"])
try:
if isinstance(data["id_event"], int):
result = gs.SqlQuery(sql)
else:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def get_comments_by_id_news(id_news):
"""
Метод извлекает все комментарии по id_news
:param id_news: ID новости для которой извлекаются комментарии
:return: dict
"""
sql = "SELECT * FROM Comments c WHERE c.id_news = {id_news} ORDER BY c.id_comment_parent"\
.format(id_news=id_news)
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR_CONNECT_DATABASE}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def info_event(id_event):
"""
Метод возвращает название события
:param id_event: int, id события
:return:
"""
sql = """Select name from event where id_event = {id_event}""".format(id_event=id_event)
#print(sql)
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result[0]}
def get_user_name(id_user):
"""
Метод возвращает имя пользователя
:param id_user: int, id пользователя
:return:
"""
sql = """Select name from users where id_user = {id_user}""".format(
id_user=id_user)
print(sql)
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result[0]}
def update_status_open_events():
"""
Метод запускает событие, если оно началось либо закончился перерыв
:return:
"""
sql = """update event
set status = 1
where (CURRENT_TIMESTAMP >= date_start and CURRENT_TIMESTAMP < date_stop)
or (CURRENT_TIMESTAMP >= date_continue and CURRENT_TIMESTAMP < date_end)
and status = 0
"""
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def update_status_close_events():
"""
Метод закрывает событие, если оно закончилось либо закрыто на перерыв
:return:
"""
sql = """update event
set status = 0
where CURRENT_TIMESTAMP >= date_end
or (CURRENT_TIMESTAMP >= date_stop and CURRENT_TIMESTAMP < date_continue)
and status = 1
"""
try:
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
def update_event_table(user_data):
"""
Метод обновляет запись в таблице "События"
:param user_data: dict информация о событии
:return: {names.ANSWER: ответ}
"""
try:
sql = """UPDATE event
SET Name='{Name}', Description='{Description}', Logo='{Logo}',
Status='{Status}', Date_start='{Date_start}', Date_end='{Date_end}',
Date_stop='{Date_stop}', Date_continue='{Date_continue}' WHERE id_event='{id_event}'""".format(
**user_data)
gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS}
def check_event(data):
"""
Метод проверяет существует ли событие
:param data: dict: id_event
:return: True or False
"""
try:
sql = "SELECT name FROM event WHERE id_event=\'{id_event}\'".format(
**data)
#print(sql)
answer = gs.SqlQuery(sql)
if answer != []:
return True
else:
return False
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return False
def check_registration(data):
"""
Метод проверки, зарегестрирован ли пользователь на данное событие
:param data: dict: id_user, id_event
:return: True or False
"""
try:
sql = "SELECT id_user FROM participation WHERE id_user=\'{id_user}\' and id_event=\'{id_event}\'".format(
**data)
#print(sql)
answer = gs.SqlQuery(sql)
if answer == []:
return True
else:
return False
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return False
def input_event_table(event_data):
"""
Метод добавляет запись в таблицу "События"
:param event_data: dict информация о событии
:return: {names.ANSWER: ответ}
"""
try:
sql = """INSERT INTO event ("name", description, logo, status, date_start, date_end, date_stop, date_continue)
VALUES (\'{Name}\', \'{Description}\',
\'{Logo}\', \'{Status}\', \'{Date_start}\', \'{Date_end}\',
\'{Date_stop}\', \'{Date_continue}\')""".format(**event_data)
print(sql)
gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS}
def get_login(id_user):
"""
Метод получает логин по ID пользователя
:param id_user: ID пользователя
:return: str Логин пользователя
"""
try:
sql = "SELECT Login FROM Auth WHERE User = '******'".format(id_user)
result = gs.SqlQuery(sql)
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return None
try:
if len(result) == 0:
return None
except:
return None
return result[names.LOGIN]
def current_event(count):
"""
Метод возвращает 10 событий, начиная с заданного номера и если они еще не начались
:param count: int номер события, с которого начинать вывод
:return: {names.ANSWER: names.SUCCESS, names.DATA: result}
"""
sql = "SELECT Name, Description, Status, Date_start, Date_end " \
"FROM Event WHERE Date_start < {} LIMIT 10 OFFSET {}".format(time.time(), count)
try:
if isinstance(count, int) and count >= 0:
result = gs.SqlQuery(sql)
else:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
except:
logging.error(names.ERROR_EXECUTE_DATABASE)
return {names.ANSWER: names.ERROR}
return {names.ANSWER: names.SUCCESS, names.DATA: result}
