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 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 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 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 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)