def send_sms(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
return service.send_sms(request.get("address"), request.get("text"))
def recover_password(cls, user, request: Request, **kwargs):
phone = Phone(request.get("phone")).get_value()
target_user = cls.users_collection().get_item({"account.login": phone, "phone_verified": True})
if target_user.email_verified:
cls.auth_service().change_password(target_user.email)
return True
if target_user.verification_code == request.get("vc1") and target_user.verification_code2 == request.get("vc2"):
target_user.email_verified = True
target_user.verification_code = None
target_user.verification_code_failed_attempts = 0
target_user.save()
cls.auth_service().change_password(target_user.email)
return True
else:
target_user.verification_code_failed_attempts += 1
if target_user.verification_code_failed_attempts < 3:
target_user.save()
raise IncorrectVerificationCode()
else:
target_user.email = None
target_user.email_verified = False
target_user.verification_code = None
target_user.verification_code2 = None
target_user.verification_code_failed_attempts = 0
target_user.save()
raise IncorrectVerificationCodeFatal()
def confirm_email_and_auth(cls, user, request: Request, **kwargs):
phone = Phone(request.get("phone")).get_value()
target_user = cls.users_collection().get_item({"account.login": phone, "phone_verified": True})
if target_user.verification_code == request.get("vc1") and target_user.verification_code2 == request.get("vc2"):
target_user.email_verified = True
target_user.verification_code = None
target_user.verification_code_failed_attempts = 0
target_user.save()
user.refresh()
cls.auth_service().send_email_confirmation_success(target_user.email)
return {
"user": user.stringify(["position_name", "name", "phone", "phone_verified", "email", "email_verified"]),
"preview_randomizer": datetime.now().microsecond
}
else:
target_user.verification_code_failed_attempts += 1
if target_user.verification_code_failed_attempts < 3:
target_user.save()
raise IncorrectVerificationCode()
else:
target_user.email = None
target_user.email_verified = False
target_user.verification_code = None
target_user.verification_code2 = None
target_user.verification_code_failed_attempts = 0
target_user.save()
raise IncorrectVerificationCodeFatal()
def test_getter(self):
""" Запрос инициализируется любым количеством словарей """
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertEqual(1, request.get('a'))
self.assertEqual(2, request.get('b'))
self.assertEqual(3, request.get('c'))
self.assertEqual(4, request.get('d'))
def test_getter_default(self):
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertRaises(Request.RequiredArgumentIsMissing, request.get, 'x')
self.assertEqual("xxx", request.get('x', "xxx"))
self.assertEqual("xxx", request.get('x', default="xxx"))
self.assertEqual(None, request.get('x', None))
self.assertEqual(None, request.get('x', default=None))
def test_getter_default(self):
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertRaises(Request.RequiredArgumentIsMissing, request.get, 'x')
self.assertEqual("xxx", request.get('x', "xxx"))
self.assertEqual("xxx", request.get('x', default="xxx"))
self.assertEqual(None, request.get('x', None))
self.assertEqual(None, request.get('x', default=None))
def crop(request: Request, *args, **kwargs):
""" Обрезает загруженное изображение
:param request:
:param args:
:param kwargs:
:return:
"""
payload = {
"base64": request.get("img"),
"coords": request.get("coords"),
"from_size": request.get("from_size")
}
cropped_base64 = microservice("http://img/crop", payload, "base64")
resized_base64_800 = microservice("http://img/scale", {
"base64": cropped_base64,
"size": 800
}, "base64")
resized_base64_400 = microservice("http://img/scale", {
"base64": cropped_base64,
"size": 400
}, "base64")
return {
"url":
microservice("http://s3/upload", {'base64': resized_base64_400},
"url"),
"url_800":
microservice("http://s3/upload", {'base64': resized_base64_800},
"url")
}
def test_getter(self):
""" Запрос инициализируется любым количеством словарей """
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertEqual(1, request.get('a'))
self.assertEqual(2, request.get('b'))
self.assertEqual(3, request.get('c'))
self.assertEqual(4, request.get('d'))
def upload(request: Request, *args, **kwargs):
""" Загружает изображение в облако и возвращает URL
:param request:
:param args:
:param kwargs:
:return:
"""
if request.get("size", False):
size = int(request.get("size"))
resized_base64 = microservice("http://img/scale", {
"base64": request.get("img"),
"size": size
}, "base64")
return {
"url_%s" % size:
microservice("http://s3/upload", {'base64': resized_base64},
"url")
}
else:
resized_base64_800 = microservice("http://img/scale", {
"base64": request.get("img"),
"size": 800
}, "base64")
resized_base64_400 = microservice("http://img/scale", {
"base64": resized_base64_800,
"size": 400
}, "base64")
return {
"url_800":
microservice("http://s3/upload",
{'base64': resized_base64_800}, "url"),
"url_400":
microservice("http://s3/upload",
{'base64': resized_base64_400}, "url")
}
def send_email(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
html = base64.b64decode(request.get("base64").replace(" ", "+").encode()).decode()
return service.send_email(request.get("address"), request.get("subject"), html)
def get_wishlist(cls, request: Request, *args, **kwargs):
""" Метод для получения списка избранных товаров покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
wishlist = carts.get_cart(int(request.get("wishlist_id")) if request.get("wishlist_id", None) else None)
return {"wishlist": wishlist.get_data() if wishlist else None}
def get_cart(cls, request: Request, *args, **kwargs):
""" Метод для получения объекта корзины покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
cart = carts.get_cart(int(request.get("cart_id")) if request.get("cart_id", None) else None)
return {"cart": cart.get_data()}
def auth(cls, request: Request, **kwargs):
""" Authenticating """
token = request.get("token", None)
if token:
return CredentialsRecords.auth_by_token(token)
else:
login = request.get("login")
password = request.get("password")
return CredentialsRecords.auth(login, password)
def crop(request: Request, *args, **kwargs):
import requests
import json
payload = {'img': request.get("img"), 'coords': json.dumps(request.get("coords")), "from_size": json.dumps(request.get("from_size"))}
r = requests.post("http://z9img/crop", data=payload)
if r.status_code == 200:
return r.text
else:
return request.get("img")
def send_sms(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
as_json = request.get("as_json", False)
result = service.send_sms(request.get("address"), request.get("text"))
return result if not as_json else {"result": result}
def crop(cls, request: Request, **kwargs):
""" Метод для обрезки изображения
:param request:
:param kwargs:
:return:
"""
bytes_object = BytesIO(base64.b64decode(request.get("base64").replace(" ", "+").encode()))
converted = ImageProcessor(bytes_object).crop(request.get("coords"), request.get("from_size"))
return {"base64": base64.b64encode(converted.getvalue()).decode()}
def auth(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
login = request.get("login")
password = request.get("password")
return microservice("http://auth/auth", {"login": login, "password": password}, "result")
def create_category(cls, request: Request, *args, **kwargs):
""" Метод для создания новых рубрик
:param request:
:param args:
:param kwargs:
:return:
"""
catalog.create_category(request.get("category_name"), request.get("slug"))
return {"categories": catalog.get_categories()}
def authenticate_vk(cls, request: Request, **kwargs):
""" Метод для выполнения аутентификации через Вк
:param request:
:param kwargs:
:return:
"""
code = request.get("code")
redirect_url = request.get("redirect_url", None)
return service.authenticate_vk(cls.build_credentials(request), code, redirect_url)
def upload(request: Request, *args, **kwargs):
import requests
import json
payload = {'base64': request.get("img")}
r = requests.post("http://z9s3/upload", data=payload)
if r.status_code == 200:
return json.loads(r.text).get("url")
else:
return request.get("img")
def scale(cls, request: Request, **kwargs):
""" Метод для изменения размера изображения (масштабирование)
:param request:
:param kwargs:
:return:
"""
bytes_object = BytesIO(base64.b64decode(request.get("base64").replace(" ", "+").encode()))
converted = ImageProcessor(bytes_object).scale(request.get("size"))
return {"base64": base64.b64encode(converted.getvalue()).decode()}
def delete(cls, request: Request, *args, **kwargs):
""" Метод для удаления поста
:param request:
:param kwargs:
:return:
"""
if request.get("id", False):
return {"result": catalog.delete_item(request.get("id"))}
return {"result": False}
def add_to_cart(cls, request: Request, *args, **kwargs):
""" Метод для добавления товара в корзину покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
cart = carts.get_cart(int(request.get("cart_id")) if request.get("cart_id", None) else None)
cart.add_item(int(request.get("item_id")), int(request.get("quantity")))
return {"cart": cart.get_data()}
def remove_from_cart(cls, request: Request, *args, **kwargs):
""" Метод для удаление товара из корзины покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
cart = carts.get_cart(int(request.get("cart_id")) if request.get("cart_id", None) else None)
cart.remove_item(int(request.get("item_id")))
return {"cart": cart.get_data()}
def set_quantity_for_item(cls, request: Request, *args, **kwargs):
""" Метод для установки количества товара в корзине покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
cart = carts.get_cart(int(request.get("cart_id")) if request.get("cart_id", None) else None)
cart.set_quantity_for_item(int(request.get("item_id")), int(request.get("quantity")))
return {"cart": cart.get_data()}
def clear_wishlist(cls, request: Request, *args, **kwargs):
""" Метод для очистки избранного покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
wishlist = carts.get_cart(int(request.get("wishlist_id")) if request.get("wishlist_id", None) else None)
wishlist.clear()
return {"wishlist": wishlist.get_data()}
def set_new_password(cls, request: Request, **kwargs):
""" Метод для восстановления пароля пользователя
:param request:
:param kwargs:
:return:
"""
return service.set_new_password(cls.build_credentials(request),
request.get("current_password"),
request.get("new_password"),
request.get("new_password2"))
def add_to_wishlist(cls, request: Request, *args, **kwargs):
""" Метод для добавления товара в избранное покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
wishlist = carts.get_cart(int(request.get("wishlist_id")) if request.get("wishlist_id", None) else None)
wishlist.add_item(int(request.get("item_id")), int(request.get("quantity")))
return {"wishlist": wishlist.get_data()}
def remove_from_wishlist(cls, request: Request, *args, **kwargs):
""" Метод для удаление товара из избранного покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
wishlist = carts.get_cart(int(request.get("wishlist_id")) if request.get("wishlist_id", None) else None)
wishlist.remove_item(int(request.get("item_id")))
return {"wishlist": wishlist.get_data()}
def update_customer(cls, request: Request, *args, **kwargs):
""" Метод для изменения объекта покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
customer = customers.get_customer(int(request.get("customer_id")))
customer.update(request.get("name"), request.get("address"))
return customer.get_data() if customer else None
def clear_cart(cls, request: Request, *args, **kwargs):
""" Метод для очистки корзины покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
cart = carts.get_cart(int(request.get("cart_id")) if request.get("cart_id", None) else None)
cart.clear()
return {"cart": cart.get_data()}
def test_override(self):
""" Из нескольких значений аргумента в запросе сохранится последнее переданное """
request = Request({'prop': 1}, {'prop': 2})
self.assertEqual(2, request.get('prop'))
request.set('prop', 3)
self.assertEqual(3, request.get('prop'))
request.update({'prop': 4})
self.assertEqual(4, request.get('prop'))
def set_quantity_for_wishlist_item(cls, request: Request, *args, **kwargs):
""" Метод для установки количества товара в избранном покупателя
:param request:
:param args:
:param kwargs:
:return:
"""
wishlist = carts.get_cart(int(request.get("wishlist_id")) if request.get("wishlist_id", None) else None)
wishlist.set_quantity_for_item(int(request.get("item_id")), int(request.get("quantity")))
return {"wishlist": wishlist.get_data()}
def authenticate_vk(cls, request: Request, **kwargs):
""" Метод для выполнения аутентификации через Вк
:param request:
:param kwargs:
:return:
"""
code = request.get("code")
redirect_url = request.get("redirect_url", None)
return service.authenticate_vk(cls.build_credentials(request), code,
redirect_url)
def authentificate_by_request(cls, request: Request):
"""
Выполняет аутентификацию пользователя по переданному объекту Request
:param request: Запрос пользователя
:return:
"""
return cls.authentificate(
(request.get("login"), request.get("password")) if request.get("login", False) else None,
request.get("token", False)
)
def get_transactions(cls, request: Request, **kwargs):
""" Get history of transactions """
login = request.get("login")
period_starts = datetime.strptime(request.get("period_starts"), "%c") \
if request.get("period_starts", None) else None
period_ends = datetime.strptime(request.get("period_ends"), "%c") \
if request.get("period_ends", None) else None
return Wallets.get_transactions(login, period_starts, period_ends)
def test_override(self):
""" Из нескольких значений аргумента в запросе сохранится последнее переданное """
request = Request({'prop': 1}, {'prop': 2})
self.assertEqual(2, request.get('prop'))
request.set('prop', 3)
self.assertEqual(3, request.get('prop'))
request.update({'prop': 4})
self.assertEqual(4, request.get('prop'))
def set_new_password(cls, request: Request, **kwargs):
""" Метод для восстановления пароля пользователя
:param request:
:param kwargs:
:return:
"""
return service.set_new_password(
cls.build_credentials(request), request.get("current_password"),
request.get("new_password"), request.get("new_password2")
)
def fill_cart_from_wishlist(cls, request: Request, *args, **kwargs):
""" Метод для копирования товаров из избранного в корзину пользователя
:param request:
:param args:
:param kwargs:
:return:
"""
wishlist = carts.get_cart(int(request.get("wishlist_id")) if request.get("wishlist_id", None) else None)
cart = carts.get_cart(int(request.get("cart_id")) if request.get("cart_id", None) else None)
wishlist.copy_to(cart)
return {"cart": cart.get_data()}
def upload(cls, request: Request, **kwargs):
""" Метод для загрузки файла с любым ключом
:param request:
:param kwargs:
:return:
"""
if request.get("file", False):
file_name, file_body = request.get_file("file")
file_obj = BytesIO(file_body)
else:
file_obj = BytesIO(base64.b64decode(request.get("base64").replace(" ", "+").encode()))
key, url = uploader.upload(file_obj)
return {"key": key, "url": url}
def saveRate(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
base_currency = request.get("base_currency")
value = request.get("value")
datetime = request.get("datetime")
return microservice("http://converter/save", {
"base_currency": base_currency,
"value": value,
"datetime": datetime
}, "result")
def getTransactions(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
login = request.get("login")
period_starts = request.get("period_starts", None)
period_ends = request.get("period_ends", None)
return microservice(
"http://wallets/get_transactions", {
"login": login,
"period_starts": period_starts,
"period_ends": period_ends
}, "result")
def topUpBalance(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
login = request.get("login")
base_currency = request.get("base_currency")
amount = request.get("amount")
microservice("http://wallets/topup", {
"login": login,
"base_currency": base_currency,
"amount": amount
}, "result")
return True
def delete_credentials(cls, request: Request, **kwargs):
""" Удаляет учетные данные по id
:param request:
:param kwargs:
:return:
"""
return service.delete_credentials(request.get("uid"))
def get_credentials(cls, request: Request, **kwargs):
""" Возвращает учетные данные по id
:param request:
:param kwargs:
:return:
"""
return service.get_credentials(request.get("uid"))
def createWallet(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
token = request.get("token")
login = microservice("http://auth/auth", {"token": token}, "result")
base_currency = request.get("base_currency")
return microservice(
"http://wallets/create",
{
"login": login,
"base_currency": base_currency
},
"result"
)
def verify_email(cls, request: Request, **kwargs):
""" Метод для подтверждения электронной почты
:param request:
:param kwargs:
:return:
"""
return service.verify_email(cls.build_credentials(request),
request.get("verification_code"))
def verify_phone(cls, request: Request, **kwargs):
""" Метод для подтверждения номера телефона
:param request:
:param kwargs:
:return:
"""
return service.verify_phone(cls.build_credentials(request),
request.get("verification_code"))
def test_getter_type_casting_exception(self):
""" Выброс исключения при невозможности приведения аргументов к нужному типу """
request = Request({'a': '1abc'})
self.assertRaises(Request.ArgumentTypeError,
request.get,
'a',
cast_type=int)
self.assertEqual('1abc', request.get('a'))
def delete_item(request: Request, *args, **kwargs):
""" Удаляет запись
:param request:
:param args:
:param kwargs:
:return:
"""
return microservice("http://catalog-api/delete",
{"id": request.get("id", False)}, "result")
def saveRatesBulk(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
data = request.get("data")
return microservice("http://converter/save_bulk", {"data": data},
"result")
def set_new_phone(cls, request: Request, **kwargs):
""" Метод для восстановления пароля пользователя
:param request:
:param kwargs:
:return:
"""
return service.set_new_phone(
cls.build_credentials(request),
normalize_phone_number(request.get("new_phone")))
def getConvertionRates(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
from_base_currency = request.get("from_base_currency")
to_base_currency = request.get("to_base_currency")
conversion_rate1 = microservice(
"http://converter/get_last_value", {"base_currency": from_base_currency}, "result"
)
conversion_rate2 = microservice(
"http://converter/get_last_value", {"base_currency": to_base_currency}, "result"
)
return {
"conversion_rate1": conversion_rate1,
"conversion_rate2": conversion_rate2
}
def transferMoney(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
token = request.get("token")
login = microservice("http://auth/auth", {"token": token}, "result")
from_base_currency = request.get("from_base_currency")
to_login = request.get("to_login")
to_base_currency = request.get("to_base_currency")
amount = request.get("amount")
conversion_rate_uuid_1 = request.get("conversion_rate_uuid_1", None)
conversion_rate_uuid_2 = request.get("conversion_rate_uuid_2", None)
return microservice(
"http://wallets/transfer",
{
"from_login": login, "from_base_currency": from_base_currency,
"to_login": to_login, "to_base_currency": to_base_currency,
"amount": amount,
"conversion_rate_uuid_1": conversion_rate_uuid_1,
"conversion_rate_uuid_2": conversion_rate_uuid_2
},
"result"
)
def create_category(request: Request, *args, **kwargs):
""" Создает новую рубрику в блоге
:param request:
:param args:
:param kwargs:
:return:
"""
payload = {"category_name": request.get("category_name", False)}
return {
"categories":
microservice("http://catalog-api/create_category", payload,
"categories")
}
def getTransactionsCsvReport(cls, request: Request, **kwargs):
"""
:param request:
:param kwargs:
:return:
"""
login = request.get("login")
period_starts = request.get("period_starts", None)
period_ends = request.get("period_ends", None)
transactions = microservice(
"http://wallets/get_transactions", {
"login": login,
"period_starts": period_starts,
"period_ends": period_ends
}, "result")
all_transactions = [tx + ["+"] for tx in transactions["incoming"]] + \
[tx + ["-"] for tx in transactions["outgoing"]]
all_transactions.sort(key=lambda tx: datetime.strptime(tx[5], "%c"))
csv_header = [
"tx_uuid", "login", "base_currency", "amount",
"convertion_rate_uuid", "tx_datetime", "mode"
]
csv_body = [csv_header]
for tx in all_transactions:
csv_body.append(tx)
file = io.StringIO()
writer = csv.writer(file, delimiter=",")
writer.writerows(csv_body)
result = file.getvalue()
request.response.add_header("Content-Type", 'application/vnd.ms-excel')
request.response.add_header(
"Content-disposition",
'attachment; filename=transactions-%s.csv' % login)
return result
def build_credentials(cls, request: Request):
""" Метод для создания экземпляра класса Credentials на основе предоставленного объекта Request
:param request:
:return:
"""
credentials = Credentials()
credentials.email = request.get("email").lower() if request.get(
"email", None) else None
credentials.phone = normalize_phone_number(
request.get("phone")) if request.get("phone", False) else None
credentials.token_name = request.get("token_name", "")
credentials.token = request.get("%stoken" % credentials.token_name,
None)
credentials.password = request.get("password", None)
credentials.vk_id = request.get("vk_id", None)
return credentials
def create(cls, request: Request, **kwargs):
""" Creating new user """
login = request.get("login")
name = request.get("name")
country_id = int(request.get("country_id")) if request.get(
"country_id", None) else None
city_id = int(request.get("city_id")) if request.get("city_id",
None) else None
return Users.create(login, name, country_id, city_id)
def change(cls, request: Request, **kwargs):
""" Updating user's data """
login = request.get("login")
name = request.get("name", None)
country_id = int(request.get("country_id")) if request.get(
"country_id", None) else None
city_id = int(request.get("city_id")) if request.get("city_id",
None) else None
return Users.change(login, name, country_id, city_id)
def get_routes(cls, request: Request, **kwargs):
"""
Отдает варианты маршрутов из точки А в точку Б в определенную дату + сортирует с лимитом по определенному полю
:param request:
:return:
"""
source = str(request.get('source'))
destination = str(request.get('destination'))
departure_date = datetime.strptime(str(request.get('departure_date')), '%Y-%m-%d').date()
limit = int(request.get('limit')) if request.get('limit', None) else 0
order_field = str(request.get('order_field')) if request.get('order_field', None) else ''
order_value = str(request.get('order_value')).lower() if request.get('order_value', None) else 'asc'
flights = RoutesHandler().calculate(source, destination, departure_date, order_field=order_field,
order_value=order_value, limit=limit)
return RoutesListSchema().dump(flights)
