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 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 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_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(self):
try:
print("Scoreboard")
self.parse_data()
answer = gs.converter(self.switch())
print("answer: ", answer)
return answer, 200, {'Access-Control-Allow-Origin': '*'}
except:
return "Error", 200, {'Access-Control-Allow-Origin': '*'}
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 parse_data(self):
self.data = self.__args.get('data', None)
self.param = self.__args.get('param', None)
if self.data is None and self.param is None:
return
self.data = gs.converter(self.data)
print("param: ", self.param)
print("data: ", self.data)
return
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_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 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 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 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 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 edit_cabinet(data):
"""
Функция получает json с id пользователя, и информацией о пользователе.
Проверяет элементы data, None или нет.
Покдлючается к базе данных с помощью функции db_connect().
Проверка есть ли id в с помощью функции check_id
Получает информацию о пользователе и перезаписывает поля в базе на те, что функция получила на вход
Если все успешно, то функция вернет {names.ANSWER: 'Succes'} и data.
"""
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 = "UPDATE users SET Name='{}', Email='{}', Sex='{}', City='{}'," \
" Educational='{}', Logo='{}', surname = '{}' WHERE id_user='******'".format(
data[names.NAME], data[names.EMAIL], data[names.SEX], data[names.CITY],
data[names.EDUCATION], data[names.LOGO], data['Surname'], data[names.ID_USER]
)
gs.SqlQuery(sql)
return {names.ANSWER: names.SUCCESS, names.DATA: data}
except:
logging.error('Fatal error: Password comparison')
return {names.ANSWER: names.ERROR}
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 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}
def filter_by_status(count, status):
"""
Метод возвращает 10 событий, начиная с заданного номера и если они закончились
:param count: int номер события, с которого начинать вывод
:param status: int Признак завершенного или активного события
:return: {names.ANSWER: names.SUCCESS, names.DATA: result}
"""
sql = "SELECT Name, Description, Date_start, Date_end FROM Event where status='{}' LIMIT 10 OFFSET {}".format(status, 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}
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 input_news_table(news_data):
"""
Метод добавляет новость в БД
:param news_data: dist данные о новости
:return: id_news
"""
sql = """INSERT INTO News (News_text, id_user, Likes_count, Dislikes_count, Date)
VALUES ('{News_text}', {id_user}, 0, 0, current_timestamp)
RETURNING id_news
""".format(News_text=news_data[names.NEWS],
id_user=news_data[names.ID_USER])
try:
id_news = gs.SqlQuery(sql)[0]['id_news']
except:
logging.error('error: Ошибка запроса к базе данных. Возможно такая новость уже есть')
return {names.ANSWER: names.WARNING,
names.DATA: "Ошибка запроса к базе данных. Возможно такая новость уже есть"}
return {names.ANSWER: names.SUCCESS, names.DATA: {"id_news": str(id_news)}}
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 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 session_verification(session):
"""
Метод проверяет, существует ли пользовательская сессия
:param session: UUID сессии
:return: int Возвращает ID пользователя
"""
try:
sql = "SELECT id_user FROM Session WHERE UUID = '{}'".format(session)
#print(sql)
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[0]["id_user"]
def logout_user(session):
"""
Метод закрывает сессию пользователя
:param session: UUID сессии, которую нужно закрыть
"""
try:
sql = "DELETE FROM Session WHERE UUID = '{}'".format(session)
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: "Сессия неверная"}
