def user_registration():
post_data = request.json
if (not request.is_json or not post_data):
return jsonify(Utils().createFailMessage("Invalid Payload")), 400
name = post_data["name"]
email = post_data["email"]
cpf = post_data["cpf"]
password = post_data["password"]
url_avatar = post_data["url_avatar"]
user = UserModel(name, email, cpf, password, url_avatar)
if UserModel.find_by_email(email):
return jsonify(Utils().createFailMessage(
'{} already exists'.format(email))), 400
try:
user.save_to_db()
auth_token = user.encode_auth_token(user.user_id)
response_object = Utils().createSuccessMessage('User was created')
user = UserModel.find_by_email(email)
provider = ProviderModel.find_provider(user.user_id)
response_object["auth_token"] = auth_token.decode()
response_object["name"] = name
response_object["email"] = email
response_object["id"] = user.user_id
response_object["is_provider"] = False
response_object["provider_id"] = None
response_object["url_avatar"] = None
return jsonify(response_object), 201
except:
db.session.rollback()
return jsonify(Utils().createFailMessage('Try again later')), 503
def order_providers_by_review(provider_category_id):
utils = Utils()
# Adding the provider's name field to provider's info returned
providers_info = utils.append_user_infos_to_provider(provider_category_id)
providers_with_review = utils.append_review_to_provider(providers_info)
context = Context(ReviewStrategy())
providers = context.execute_sorting(provider_category_id)
return json.dumps(providers)
def get_providers_by_category_min_price(provider_category_id):
utils = Utils()
# Adding the provider's name field to provider's info returned
providers_info = utils.append_user_infos_to_provider(provider_category_id)
if not providers_info:
response = {'status': 'failed', 'error': "ID Not Found"}
return jsonify(response), 404
context = Context(PriceStrategy())
providers_info = context.execute_sorting(provider_category_id)
return jsonify(providers_info), 200
def remove_category_provider_relationship(provider_id, provider_category_id):
works = WorksModel.query.filter_by(
provider_category_id=int(provider_category_id),
provider_id=int(provider_id)).first()
if not works:
return jsonify(
Utils().createFailMessage('Relationship Not Found')), 404
db.session.delete(works)
db.session.commit()
return jsonify(Utils().createSuccessMessage('Relationship deleted!')), 200
def add_address():
post_data = request.json
if (not request.is_json or not post_data):
return jsonify(Utils().createFailMessage("Invalid Payload")), 400
user_id = post_data["user_id"]
street = post_data["street"]
neighborhood = post_data["neighborhood"]
number = post_data["number"]
city = post_data["city"]
cep = post_data["cep"]
state = post_data["state"]
try:
complement = post_data["complement"]
except:
complement = None
try:
reference_point = post_data["reference_point"]
except:
reference_point = None
address = AddressModel(street, neighborhood, number, complement, city, cep,
state, reference_point)
try:
address.save_to_db()
except:
db.session.rollback()
return jsonify(Utils().createFailMessage('Try again later')), 503
lives = LivesModel(user_id, address.address_id)
try:
lives.save_to_db()
response_object = Utils().createSuccessMessage('Address registered')
return jsonify(response_object), 201
except:
db.session.rollback()
return jsonify(Utils().createFailMessage('Try again later')), 503
def provider_registration():
post_data = request.json
if (not request.is_json or not post_data):
return jsonify(Utils().createFailMessage("Invalid Payload")), 400
db.session.rollback()
minimum_price = post_data["minimum_price"]
maximum_price = post_data["maximum_price"]
bio = post_data["bio"]
url_rg_photo = post_data["url_rg_photo"]
url_avatar = post_data["url_avatar"]
number = post_data["number"]
user_id = post_data["user_id"]
provider_categories = post_data["categories"]
categories = json.loads(provider_categories)
user = UserModel.find(user_id)
try:
user.url_avatar = url_avatar
db.session.commit()
except Exception as e:
db.session.rollback()
return jsonify(Utils().createFailMessage('Error saving picture')), 500
provider = ProviderModel(minimum_price, maximum_price, bio, url_rg_photo,
number, user_id)
try:
provider.save_to_db()
response_object = Utils().createSuccessMessage('Provider was created')
provider = ProviderModel.find_provider(user_id)
response_object[
"provider_id"] = provider.provider_id if provider is not None else None
for category in categories:
work = WorksModel(category["id"], provider.provider_id)
work.save_to_db()
return jsonify(response_object), 200
except Exception as e:
db.session.rollback()
return jsonify(Utils().createFailMessage('Try again later')), 503
def user_login():
post_data = request.json
if (not request.is_json or not post_data):
return jsonify(Utils().createFailMessage("Invalid Payload")), 400
email = post_data["email"]
password = post_data["password"]
try:
current_user = UserModel.find_by_email(email)
if not current_user:
return jsonify(Utils().createFailMessage(
'User {} doesn\'t exist'.format(email))), 404
if current_user and bcrypt.check_password_hash(current_user.password,
password):
provider = ProviderModel.find_provider(current_user.user_id)
auth_token = current_user.encode_auth_token(current_user.user_id)
response_object = Utils().createSuccessMessage(
'Successfully logged in.')
response_object["auth_token"] = auth_token.decode()
response_object["name"] = current_user.name
response_object["email"] = current_user.email
response_object["id"] = current_user.user_id
response_object["is_provider"] = provider is not None
response_object[
"provider_id"] = provider.provider_id if provider is not None else None
response_object["url_avatar"] = current_user.url_avatar
return jsonify(response_object), 200
else:
return jsonify(Utils().createFailMessage('Wrong Credentials')), 401
except Exception as ex:
db.session.rollback()
return jsonify(Utils().createFailMessage(ex)), 500
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import List
from project.api.utils.creation_utils import Utils
from project.api.models import Pax
utils = Utils()
class Context():
def __init__(self, strategy: Strategy) -> None:
self._strategy = strategy
@property
def strategy(self) -> Strategy:
return self._strategy
@strategy.setter
def strategy(self, strategy: Strategy) -> None:
self._strategy = strategy
def execute_filtering(self, user_type, id) -> list:
result = self._strategy.filter_status(user_type, id)
return result
class Strategy(ABC):
@abstractmethod
def filter_status(self, user_type, id):
pass
def sort_providers(self, data: list) -> list:
data = Utils().append_review_to_provider(data)
providers_info = sorted(
data, key=lambda element: element['reviews_average'], reverse=True)
return providers_info
def execute_sorting(self, provider_category_id) -> dict:
providers_info = Utils().append_user_infos_to_provider(provider_category_id)
result = self._strategy.sort_providers(providers_info)
return result