def change_status_vacancy():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
change_status_data = request.get_json(silent=True)
if not change_status_data:
return jsonify(text="JSON не найден"), 204
directories = [(None, "status_id"), (None, "vacancy_id")]
check = check_fields(directories, change_status_data)
if type(check) == list:
return "В json отсутсвуют поля: {}".format(",".join(i for i in check))
result = database.insert_data(
sql.SQL(
"UPDATE vacancy SET status_id={status_id} WHERE id={vacancy_id}").
format(status_id=sql.Literal(change_status_data['status_id']),
vacancy_id=sql.Literal(change_status_data['vacancy_id'])))
database.close()
return jsonify(result)
def documets():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
result = {}
if request.method == "GET":
pk = str(crypto_file.generate_public_key()).split('\\n')
result = {
"document_type": {},
"public_key": ''.join(i for i in pk[1:-1])
}
for row in database.select_data(
"SELECT id, title FROM document_type;"):
result["document_type"][row[0]] = row[1]
elif request.method == "POST":
json = request.get_json(silent=True)
if not json:
return jsonify({"message": "JSON не найден"}), 400
fields = ["hash", "document_type_id", "photo"]
for field in fields:
if not json.get(field):
return jsonify({"message": f"Поле {field} не найдено"}), 400
hash_md5 = hashlib.md5()
hash_md5.update(str(json.get("photo")).encode())
if not hash_md5.hexdigest() == json.get("hash").lower():
return jsonify({"message": f"hash не совпадает"}), 406
query = "INSERT INTO {table}({fields}) VALUES ({values}, now())"
values = {
"table":
sql.Identifier("public", "documents"),
"fields":
sql.SQL(",").join(
sql.Identifier(i) for i in
["hash", "user_id", "document_type_id", "photo", "dt_upload"]),
"values":
sql.SQL(",").join(
sql.Literal(i) for i in [
json.get("hash"),
user.get_id(),
json.get("document_type_id"),
json.get("photo"),
])
}
result = database.insert_data(sql.SQL(query).format(**values))
database.close()
return jsonify(result)
def check_status():
"""Status"""
vozvrat = {}
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
query = sql.SQL("SELECT fns_id FROM public.user_fns WHERE user_id=" +
str(user.get_id()))
try:
query_id = database.select_data(query)[0]
except:
vozvrat["messageError"] = "Данной заявки нет"
return jsonify(vozvrat)
# inn = str(user.get_inn())
if check_farmer().get("payload").get("result") == "COMPLETED":
vozvrat["result"] = "Заявка успешно подтверждена"
else:
vozvrat["messageError"] = "Заявка не подтверждена"
return jsonify(vozvrat)
def get_directories_for_vacancies():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
result = {"professional_area": {}}
directories = [(["id", "title"], "skills"),
(["id", "title"], "work_address"),
(["id", "title"], "type_employment"),
(["id", "title"], "soft_requirements"),
(["id", "title"], "technologies_and_tools"),
(["id", "title", "description"], "grade"),
(["id", "title", "description"], "working_conditions"),
(["id", "title", "description"], "job_responsibilities"),
(["id", "title", "description"], "special_advantages")]
for fields, table in directories:
result[table] = select_info(database, fields, table)
res = database.select_data("""
SELECT
s.id,
s.title,
s.description,
pa.id,
pa.title
FROM specializations s
LEFT JOIN professional_area pa on pa.id = s.professional_area_id
""")
for id, title, description, pa_id, pa_title in res:
if not result["professional_area"].get(pa_title):
result["professional_area"][pa_title] = {
"specializations": [],
"title": pa_title,
"id": pa_id
}
result["professional_area"][pa_title]["specializations"].append({
"id":
id,
"title":
title,
"description":
description
})
result["professional_area"] = [
result["professional_area"][i] for i in result["professional_area"]
]
database.close()
return jsonify(result)
def create_new_vacancy():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
vacancy_data = request.get_json(silent=True)
if not vacancy_data:
return jsonify(text="JSON не найден"), 204
directories = [(["title"], "skills"), (["title"], "work_address"),
(["title"], "type_employment"),
(["title"], "soft_requirements"),
(["title"], "professional_area"),
(["title"], "technologies_and_tools"),
(["title", "description"], "grade"),
(["title", "description"], "working_conditions"),
(["title", "description"], "job_responsibilities"),
(["title", "description"], "special_advantages"),
(["title", "description",
"professional_area_id"], "specializations")]
check = check_fields(directories, vacancy_data)
if type(check) == list:
return "В json отсутсвуют поля: {}".format(",".join(i for i in check))
values = {}
for fields, table in directories:
for value in vacancy_data[table]:
if not values.get(table):
values[table] = []
if type(value) == int:
values[table].append(value)
elif type(value) == list:
if table == "specializations":
value.append(values["professional_area"][0])
id = insert_new_data_in_directory(database, fields, value,
table)
if type(id) == int:
values[table].append(id)
elif type(value) == str:
id = insert_new_data_in_directory(database, fields, [value],
table)
if type(id) == int:
values[table].append(id)
values["is_testing"] = bool(vacancy_data['is_testing'])
check = insert_vacancy(database, values, user)
database.close()
return jsonify(check)
def logout():
"""Logout Page"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
authorize.pop(user.get_token())
return jsonify({'message': 'Пользователь вышел'}), 401, {'ContentType': 'application/json'}
def get_label():
"""Add product in favorite for user"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
vozvrat = {}
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
vozvrat = []
fields = [
"u.firstname", "u.lastname", "up.id", "up.name", "up.photo", "up.type",
"up.method", "up.sale", "up.price", "c.name", "up.weight", "u2.name",
"fp.id", "a.country", "a.city", "a.address", "a.lat", "a.lng"
]
query = sql.SQL("SELECT {} FROM users u \
RIGHT JOIN users_product up on u.id = up.user_id\
LEFT JOIN units u2 on up.unit_id = u2.id\
LEFT JOIN currencys c on up.currency_id = c.id\
LEFT JOIN favorit_products fp on u.id = fp.user_id\
LEFT JOIN address a on up.address_id = a.id").format(
sql.SQL(",").join(
sql.Identifier(i.split('.')[0],
i.split('.')[1]) for i in fields))
execute = database.select_data(query)
if type(execute) != list:
return execute
data_append = {}
for row in execute:
for i in range(len(fields)):
value = row[i]
if fields[i] == "up.id":
fields[i] = "up.users_product_id"
if fields[i] == "c.name":
fields[i] = "c.currency"
if fields[i] == "u2.name":
fields[i] = "u2.unit"
if fields[i] == "fp.id":
fields[i] = "fp.is_favorit"
value = True if value != None else False
data_append[fields[i].split('.')[1]] = value
vozvrat.append(data_append)
return jsonify(vozvrat)
def get_all_vacancy():
user = check_auth(request.headers, __name__)
if user == True:
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
status_id = [2]
fields = [("v", "id"), ("v", "create_date"), ("sp", "title"),
("pa", "title"), ("sv", "title")]
if type(user) != tuple:
if user.get_role() == 1:
status_id = [1, 2, 3]
result = []
res = database.select_data(
sql.SQL("""
SELECT
{fields}
FROM vacancy v
LEFT JOIN specializations sp on sp.id = v.specializations_id
LEFT JOIN professional_area pa on pa.id = sp.professional_area_id
LEFT JOIN statuses_vacancy sv on sv.id = v.status_id
WHERE
status_id in ({status_id})
""").format(fields=sql.SQL(",").join(
sql.Identifier(i[0], i[1]) for i in fields),
status_id=sql.SQL(",").join(sql.Literal(i)
for i in status_id)))
if res:
for id, dt, specialization, professional_area, status in res:
result.append({
"id":
id,
"dt":
time.mktime(
datetime.datetime.strptime(dt.strftime("%d/%m/%Y"),
"%d/%m/%Y").timetuple()),
"specialization":
specialization,
"professional_area":
professional_area
})
if type(user) != tuple:
if user.get_role() == 1:
result[-1]['status'] = status
database.close()
return jsonify(result)
def get_status_code(isCall=False):
if not isCall:
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
result = {}
for row in database.select_data("SELECT id, title FROM status_code;"):
result[row[0]] = row[1]
database.close()
return jsonify(result)
def add_grow():
"""Grow"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
vozvrat = {}
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
# Получение существующих юнитов
if request.method == 'GET':
vozvrat = get_units(database, user.get_id())
return jsonify(vozvrat)
# Добавление новой карточки товара
elif request.method == 'POST':
file = request.get_json(silent=True)
if file != None:
product = {
"user_id": user.get_id(),
"method": file.get("method"),
"name": file.get("name"),
"type": file.get("type"),
"photo": file.get("photo"),
"price": file.get("price"),
"currency_id": file.get("currency_id"),
"weight": file.get("weight"),
"unit_id": file.get("unit_id"),
"sale": file.get("sale"),
}
result = execute_to_base(database, product)
if result == True:
vozvrat["messageSuccess"] = "Карточка успешно добавлена"
else:
vozvrat["messageError"] = result
else:
vozvrat["messageError"] = "JSON отсутсвует"
return jsonify(vozvrat)
def get_statuses_vacancy():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
result = []
statuses = database.select_data("SELECT id, title FROM statuses_vacancy")
for id, title in statuses:
result.append({"id": id, "title": title})
database.close()
return jsonify(result)
def my_documents_processing():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
result = []
query = """
SELECT
doc.id,
u.lastname,
u.firstname,
u.patronymic,
doc.dt_upload,
dt.title,
sc.title
FROM documents doc
LEFT JOIN document_processing dp ON dp.document_id = doc.id
LEFT JOIN users u ON u.id = doc.user_id
LEFT JOIN document_type dt ON dt.id = doc.document_type_id
LEFT JOIN status_code sc ON sc.id = dp.status_code_id
WHERE dp.manager_id={};""".format(user.get_id())
for row in database.select_data(query):
result.append({
"document_id": row[0],
"lastname": row[1],
"firstname": row[2],
"patronymic": row[3],
"dt_upload": row[4],
"document_type": row[5],
"status_code": row[6]
})
database.close()
return jsonify(result)
def get_directories_for_questions():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
result = {}
directories = [(["id", "title"], "skills"),
(["id", "title", "description"], "grade"),
(["id", "title", "description"], "question_types")]
for fields, table in directories:
result[table] = select_info(database, fields, table)
database.close()
return jsonify(result)
def order():
"""Order"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
vozvrat = {}
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
file = request.get_json(silent=True)
if file != None:
# Получение корзины
cart = get_cart()
# Отправка order в базу данных
order = {
"user_id": user.get_id(),
"method": file.get("method"),
"name": file.get("name"),
"type": file.get("type"),
"photo": file.get("photo"),
"price": file.get("price"),
"currency_id": file.get("currency_id"),
"weight": file.get("weight"),
"unit_id": file.get("unit_id"),
"sale": file.get("sale"),
}
result = execute_to_base(database, product)
if result == True:
vozvrat["messageSuccess"] = "Карточка успешно добавлена"
else:
vozvrat["messageError"] = result
else:
vozvrat["messageError"] = "JSON отсутсвует"
return jsonify(vozvrat)
def analiz_all_candidates():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
result = {}
candidates = database.select_data("""
SELECT
c.id candidates_id,
c.firstname candidates_firstname,
c.lastname candidates_lastname,
v.id vacancy_id,
s.title specializations_title,
sc.title status_title,
get_score_candidate(c.id) score
FROM candidates c
LEFT JOIN answer_on_question_candidate aoqc on c.id = aoqc.candidate_id
LEFT JOIN vacancy v on c.vacancy_id = v.id
LEFT JOIN specializations s on v.specializations_id = s.id
LEFT JOIN statuses_candidate sc on c.status_id = sc.id
""")
for candidat in candidates:
candidates_id = candidat['candidates_id']
result[candidates_id] = {}
for key in candidat.keys():
result[candidates_id][key] = candidat[key]
result = [result[key] for key in result]
database.close()
return jsonify(result)
def create_questions():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database()
except TypeError:
return jsonify({"messageError": "Нет подключения к БД"})
vacancy_data = request.get_json(silent=True)
if not vacancy_data:
return jsonify(text="JSON не найден"), 204
directories = [(["title"], "skills"), (["title", "description"], "grade"),
(["title", "description"], "question_types"),
(None, "title"), (None, "question"),
(None, "answers_on_question")]
check = check_fields(directories, vacancy_data)
if type(check) == list:
return "В json отсутсвуют поля: {}".format(",".join(i for i in check))
values = {}
for fields, table in directories:
values[table] = []
if table in ["title", "question", "skills", "grade", "question_types"]:
values[table] = vacancy_data[table]
elif table == 'answers_on_question':
for value in vacancy_data[table]:
values[table].append(value)
question_id = insert_questions(database, values)
check = insert_answers(database, question_id,
values['answers_on_question'])
database.close()
return jsonify(check)
def change_status():
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
result = {}
if request.method == 'GET':
return get_status_code(True)
elif request.method == 'POST':
json = request.get_json(silent=True)
if not json:
return jsonify({"message": "JSON не найден"}), 400
fields = ["document_id", "status_code_id"]
for field in fields:
if not json.get(field):
return jsonify({"message": f"Поле {field} не найдено"}), 400
query = None
values = None
isManager = database.select_data(
sql.SQL(
"SELECT manager_id FROM document_processing WHERE document_id={document_id}"
).format(document_id=sql.Literal(json.get("document_id"))))
if isManager:
isManager = isManager[0][0]
if isManager == user.get_id() and isManager:
query = "UPDATE {table} SET {fields}={values} WHERE document_id={document_id}"
values = {
"table":
sql.Identifier("public", "document_processing"),
"fields":
sql.SQL(",").join(
sql.Identifier(i) for i in ["status_code_id"]),
"values":
sql.SQL(",").join(
sql.Literal(i) for i in [json.get("status_code_id")]),
"document_id":
sql.Literal(json.get("document_id"))
}
elif isManager != user.get_id() and isManager:
return jsonify({"message": f"Документ не найден"})
else:
query = "INSERT INTO {table}({fields}) VALUES({values})"
values = {
"table":
sql.Identifier("public", "document_processing"),
"fields":
sql.SQL(",").join(
sql.Identifier(i)
for i in ["document_id", "status_code_id", "manager_id"]),
"values":
sql.SQL(",").join(
sql.Literal(i) for i in [
json.get("document_id"),
json.get("status_code_id"),
user.get_id()
])
}
result = database.insert_data(sql.SQL(query).format(**values))
database.close()
return jsonify(result)
def cart():
"""Cart user`s"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
vozvrat = None
execute = None
data_cart = {
"user_id": user.get_id()
}
if request.method == 'GET':
fields = [
"up.id",
"up.name",
"up.photo",
"c.sale",
"up.weight",
"c.weight_user",
"c.price_for_user",
"c.farmer_price",
"c2.name",
"u.name"
]
query = sql.SQL("\
SELECT\
{column}\
FROM public.cart c\
LEFT JOIN users_product up on c.users_product_id = up.id\
LEFT JOIN currencys c2 on up.currency_id = c2.id\
LEFT JOIN units u on up.unit_id = u.id\
WHERE {condition}").format(
column=sql.SQL(',').join(
sql.SQL(i) for i in fields),
condition=sql.SQL('c.user_id={user_id}').format(
user_id=sql.Literal(data_cart['user_id'])
)
)
execute = database.select_data(query)
if type(execute) != list:
return jsonify(execute)
if len(execute) == 0:
return jsonify({'messageError': "Корзина пустая"})
vozvrat = []
data_append = {}
for row in execute:
for i in range(len(fields)):
value = row[i]
if fields[i] == "up.id":
fields[i] = "up.users_product_id"
elif fields[i] == "c2.name":
fields[i] = "c2.currency"
elif fields[i] == "u.name":
fields[i] = "u.unit"
elif fields[i] == "up.weight":
fields[i] = "up.weight_farmer"
data_append[fields[i].split('.')[1]] = value
vozvrat.append(data_append)
return jsonify(vozvrat)
file = request.get_json(silent=True)
if file != None:
if file.get("users_product_id") == None or type(file.get("users_product_id")) != int:
return jsonify({"messageError": "Выберете товар, который нужно добавить в корзину"})
data_cart["users_product_id"] = int(file.get("users_product_id"))
query = sql.SQL("SELECT {column} FROM {table} WHERE {condition}").format(
table=sql.Identifier("public", "cart"),
column=sql.SQL(',').join(
sql.Identifier(i) for i in ["id"]),
condition=sql.SQL('user_id={user_id} and users_product_id={users_product_id}').format(
user_id=sql.Literal(data_cart['user_id']),
users_product_id=sql.Literal(data_cart['users_product_id'])
)
)
execute = database.select_data(query)
if type(execute) != list:
return execute
else:
vozvrat["messageError"] = "JSON отсутсвует"
if request.method == 'DELETE' and len(execute) != 0:
query = sql.SQL("DELETE FROM {table} WHERE {condition}").format(
table=sql.Identifier("public", "cart"),
condition=sql.SQL('user_id={user_id} and users_product_id={users_product_id}').format(
user_id=sql.Literal(data_cart['user_id']),
users_product_id=sql.Literal(data_cart['users_product_id'])
)
)
execute = database.insert_data(query)
if execute != True:
return execute
vozvrat = {"messageSuccess": "Товар удалён из корзины"}
elif request.method == 'DELETE' and len(execute) == 0:
return jsonify({'messageError': "Товар отсутствует в корзине"})
if request.method == 'POST' and len(execute) == 0:
data_cart["weight_user"] = float(file.get("weight"))
if data_cart["weight_user"] == None:
return jsonify({'messageError': "Укажите вес товара"})
fields = [
"weight",
"sale",
"price",
"currency_id",
"unit_id"
]
query = sql.SQL("\
SELECT\
{column}\
FROM public.users_product\
WHERE {condition}").format(
column=sql.SQL(',').join(
sql.SQL(i) for i in fields),
condition=sql.SQL('id={users_product_id}').format(
users_product_id=sql.Literal(data_cart['users_product_id'])
)
)
execute = database.select_data(query)
if type(execute) != list:
return jsonify(execute)
if len(execute) == 0:
return jsonify({'messageError': "Такого товара не существует"})
execute = execute[0]
data_cart["user_id"] = user.get_id()
data_cart["farmer_price"] = float(execute[2])
weight_farmer = float(execute[0])
data_cart["sale"] = int(execute[1])
data_cart["price_for_user"] = float(
"{:.2f}".format(
(data_cart['farmer_price'] / weight_farmer) *
data_cart['weight_user'] * (1 + data_cart["sale"] / 100)
)
)
list_value = [i[1] for i in data_cart.items()]
query = sql.SQL("INSERT INTO {table}(adding_time, {column}) VALUES(now(), {value})").format(
table=sql.Identifier("public", "cart"),
column=sql.SQL(',').join(
sql.Identifier(i) for i in data_cart),
value=sql.SQL(',').join(sql.Literal(i) for i in list_value)
)
execute = database.insert_data(query)
if execute != True:
return execute
vozvrat = {"messageSuccess": "Товар добавлен в корзину"}
elif request.method == 'POST' and len(execute) != 0:
return jsonify({'messageError': "Товар присутствует в корзине"})
return jsonify(vozvrat)
def personal_area():
"""Personal area user`s"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
vozvrat = {}
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
if request.method == "GET":
# Выдача текущих данных о пользователе
user_data = {"email": user.get_email()}
columns = [
"firstname", "lastname", "patronymic", "number_phone", "role",
"inn", "certificate", "intresting", "url_instagram", "url_vk",
"equipment_id", "fertilizer", "saleform"
]
query = sql.SQL(
"SELECT {fields} FROM {table} WHERE {condition}").format(
fields=sql.SQL(",").join(sql.Identifier(i) for i in columns),
table=sql.Identifier("public", "users"),
condition=sql.SQL("id={}").format(sql.Literal(user.get_id())))
execute = database.select_data(query)
if len(execute) == 0:
return jsonify({"messageError": "Пользователь отсутсвует"})
execute = execute[0]
for i in range(len(execute)):
user_data[columns[i]] = execute[i]
# Получения адреса пользователя
columns = ["country", "city", "address", "lat", "lng"]
query = sql.SQL(
"SELECT {fields} FROM {table} WHERE {condition}").format(
fields=sql.SQL(",").join(sql.Identifier(i) for i in columns),
table=sql.Identifier("public", "address"),
condition=sql.SQL("user_id={}").format(
sql.Literal(user.get_id())))
execute = database.select_data(query)
user_data["addressData"] = {}
if len(execute) == 0:
for i in range(len(columns)):
user_data["addressData"][columns[i]] = None
else:
execute = execute[0]
for i in range(len(execute)):
user_data["addressData"][columns[i]] = execute[i]
return jsonify(user_data)
# Изменение данных о пользователе
file = request.get_json(silent=True)
if file != None and request.method == "POST":
is_farmer = True if file.get("farmer") == True else False
user_data = {
"email": file.get("email"),
"password": file.get("password"),
"confirm_password": file.get("confirm_password"),
"firstname": file.get("firstname"),
"lastname": file.get("lastname"),
"patronymic": file.get("patronymic"),
"number_phone": file.get("number_phone"),
"role": 1 if is_farmer else 2,
"inn": file.get("inn"),
"certificate": file.get("certificate"),
"intresting": file.get("intresting"),
"url_instagram": file.get("url_instagram"),
"url_vk": file.get("url_vk"),
"equipment_id": file.get("equipment_id"),
"fertilizer": file.get("fertilizer"),
"saleform": file.get("saleform"),
"country":
file.get("addressData").get("country") if is_farmer else None,
"city": file.get("addressData").get("city") if is_farmer else None,
"address":
file.get("addressData").get("address") if is_farmer else None,
"lat": file.get("addressData").get("lat") if is_farmer else None,
"lng": file.get("addressData").get("lng") if is_farmer else None
}
# Проверка введённых данных
valid = valid_data(user_data)
if valid != True:
vozvrat["messageError"] = valid
return jsonify(vozvrat)
user_data["id"] = user.get_id()
if not user_data['password'] in [None, '']:
user_data['password'] = generate_password_hash(
user_data['password'], method='sha256')
result = execute_to_base(database, user_data)
if result == True:
vozvrat["messageSuccess"] = "Данные обновлены"
else:
vozvrat["messageError"] = result
else:
vozvrat["messageError"] = "JSON отсутсвует"
return jsonify(vozvrat)
def create_order():
"""Order"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
vozvrat = {}
database = None
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
if request.method == 'GET':
query = sql.SQL("SELECT id, name FROM {table}").format(
table=sql.Identifier("public", "payment_methods"), )
execute = database.select_data(query)
if type(execute) != list:
return execute
vozvrat['payment_methods'] = {}
for row in execute:
vozvrat['payment_methods'][row[1]] = int(row[0])
delivery_methods = {"Самовывоз": 1, "Доставка": 2}
vozvrat['delivery_methods'] = {}
for col in delivery_methods:
vozvrat['delivery_methods'][col] = delivery_methods[col]
return jsonify(vozvrat)
file = request.get_json(silent=True)
if file != None:
# Получение корзины
cart = get_cart(database, user)
if type(cart) != list:
return cart
# Отправка order в базу данных
order = {
"user_id":
user.get_id(),
"all_price":
float(
database.select_data(
"SELECT sum(price_for_user) FROM cart WHERE user_id={}".
format(user.get_id()))),
"delivery_method_id":
file.get("delivery"),
"payment_method_id":
file.get("payment_method_id"),
"payment_status":
False
}
result = execute_to_base(database, order)
if result != True:
vozvrat["messageError"] = result
result = migrations_product_list_from_cart_in_order(database, order)
if result == True:
vozvrat["messageSuccess"] = "Заказ оформлен"
else:
vozvrat["messageError"] = result
else:
vozvrat["messageError"] = "JSON отсутсвует"
return jsonify(vozvrat)
def add_favorit_product():
"""Add product in favorite for user"""
user = check_auth(request.headers, __name__)
if user != True:
return user
user = authorize.get(request.headers.get('UserToken'))
vozvrat = {}
try:
database = Database(config)
except TypeError:
vozvrat["messageError"] = "Нет подключения к БД"
return jsonify(vozvrat)
file = request.get_json(silent=True)
if file != None:
if file.get("users_product_id") == None or type(
file.get("users_product_id")) != int:
return jsonify({
"messageError":
"Выберете товар, который нужно добавить в избранное"
})
favorite = {
"user_id": user.get_id(),
"users_product_id": int(file.get("users_product_id"))
}
query = sql.SQL(
"SELECT {column} FROM {table} WHERE {condition}").format(
table=sql.Identifier("public", "favorit_products"),
column=sql.SQL(',').join(sql.Identifier(i) for i in ["id"]),
condition=sql.SQL(
'user_id={user_id} and users_product_id={users_product_id}'
).format(user_id=sql.Literal(favorite['user_id']),
users_product_id=sql.Literal(
favorite['users_product_id'])))
vozvrat = database.select_data(query)
if type(vozvrat) != list:
return vozvrat
if len(vozvrat) == 0:
query = sql.SQL(
"INSERT INTO {table}({column}) VALUES({value})").format(
table=sql.Identifier("public", "favorit_products"),
column=sql.SQL(',').join(
sql.Identifier(i)
for i in ["user_id", "users_product_id"]),
value=sql.SQL(',').join(
sql.Literal(i) for i in
[user.get_id(),
int(file.get("users_product_id"))]))
vozvrat = database.insert_data(query)
if vozvrat != True:
return vozvrat
vozvrat = {"is_favorit": True}
else:
query = sql.SQL("DELETE FROM {table} WHERE id={id}").format(
table=sql.Identifier("public", "favorit_products"),
id=sql.Literal(vozvrat[0][0]))
vozvrat = database.insert_data(query)
if vozvrat != True:
return vozvrat
vozvrat = {"is_favorit": False}
else:
vozvrat["messageError"] = "JSON отсутсвует"
return jsonify(vozvrat)
