def create():
insert_list_csv_breed()
try:
db.session.commit()
return build_api_response(HTTPStatus.CREATED)
except IntegrityError:
return build_api_response(HTTPStatus.BAD_REQUEST)
def delete(dog_id: int):
dog = verify_auth(dog_id)
if not dog:
return build_api_response(HTTPStatus.UNAUTHORIZED)
dog.delete()
db.session.commit()
return build_api_response(HTTPStatus.OK)
def patch_news(news_id):
user_id = get_jwt_identity()
data = request.get_json()
if News.query.filter_by(id=news_id).first() is not None:
service_alter_news_information(news_id, data)
else:
return build_api_response(HTTPStatus.NOT_FOUND)
return build_api_response(HTTPStatus.OK)
def delete_one_product(product_id: int):
product = Product.query.filter_by(id=product_id).first()
if product is None:
return build_api_response(HTTPStatus.NOT_FOUND)
db.session.delete(product)
db.session.commit()
return build_api_response(HTTPStatus.OK)
def delete():
user_id = get_jwt_identity()
if User.query.filter_by(id=user_id).first() is not None:
user = User.query.filter_by(id=user_id).delete()
db.session.commit()
else:
return build_api_response(HTTPStatus.NOT_FOUND)
return build_api_response(HTTPStatus.OK)
def get_one_msg(dog_id, msg_id):
owner_id = get_jwt_identity()
dog = Dog.query.filter_by(owner_id=owner_id, id=dog_id).first()
if not dog:
return build_api_response(HTTPStatus.NOT_FOUND)
data = Message.query.filter_by(dog_id=dog_id, id=msg_id).first()
if not data:
return build_api_response(HTTPStatus.NOT_FOUND)
return {"data": MessageSchema().dump(data)}, HTTPStatus.OK
def delete(photo_id):
Photo.query.get_or_404(photo_id)
result = verify_auth_delete(photo_id)
if not result:
return build_api_response(HTTPStatus.UNAUTHORIZED)
Photo.query.filter_by(id=photo_id).delete()
db.session.commit()
return build_api_response(HTTPStatus.OK)
def delete_news(news_id):
user_id = get_jwt_identity()
if News.query.filter_by(id=news_id).first() is not None:
news = News.query.get_or_404(news_id)
db.session.delete(news)
db.session.commit()
else:
return build_api_response(HTTPStatus.NOT_FOUND)
return build_api_response(HTTPStatus.OK)
def get_dog_id(interest_id: int):
dog_verify = verify_auth(interest_id)
if not dog_verify:
return build_api_response(HTTPStatus.UNAUTHORIZED)
dog = Interest.query.get(interest_id)
if not dog:
return build_api_response(HTTPStatus.NOT_FOUND)
return {'data': InterestSchema().dump(dog)}, HTTPStatus.OK
def get_interests(dog_id: int):
dog_verify = verify_auth(dog_id)
if not dog_verify:
return build_api_response(HTTPStatus.UNAUTHORIZED)
interest = Interest.query.filter_by(dog_id=dog_id).first()
if not interest:
return build_api_response(HTTPStatus.NOT_FOUND)
return {'data': InterestSchema().dump(interest)}, HTTPStatus.OK
def delete_msg(dog_id, msg_id):
owner_id = get_jwt_identity()
dog = Dog.query.filter_by(owner_id=owner_id, id=dog_id).first()
if not dog:
return {"dog": build_api_response(HTTPStatus.NOT_FOUND)}
msg = Message.query.filter_by(id=msg_id, dog_id=dog_id)
if not msg.first():
return {"msg": build_api_response(HTTPStatus.NOT_FOUND)}
msg.delete()
db.session.commit()
return build_api_response(HTTPStatus.OK)
def login():
email = request.json.get('email')
password = request.json.get('password')
if User.query.filter_by(email=email).first() is not None:
filtered_user = User.query.filter_by(email=email).first()
if User.checkPassword(filtered_user, password):
access_token = create_access_token(
identity=filtered_user.id, expires_delta=timedelta(days=14))
return {'token': access_token}
return build_api_response(HTTPStatus.UNAUTHORIZED)
return build_api_response(HTTPStatus.FORBIDDEN)
def created_new_interest():
data = request.get_json()
interest = Interest(dog_id=data["dog_id"],
breed_id=data["breed_id"],
gender_interest=data["gender_interest"])
try:
db.session.add(interest)
db.session.commit()
return build_api_response(HTTPStatus.CREATED)
except IntegrityError:
return build_api_response(HTTPStatus.BAD_REQUEST)
def get_one_conversation(dog_id, conv_id):
owner_id = get_jwt_identity()
found = Dog.query.filter_by(owner_id=owner_id, id=dog_id).first()
if not found:
return build_api_response(HTTPStatus.NOT_FOUND)
data = Conversation.query.filter_by(id=conv_id).first()
if not data:
return build_api_response(HTTPStatus.NOT_FOUND)
if found in data.dogs:
return {'data': ConversationSchema().dump(data)}, HTTPStatus.FOUND
return build_api_response(HTTPStatus.UNAUTHORIZED)
def get_one_msg(msg_id):
data = Message.query.filter_by(id=msg_id).first()
if not data:
return build_api_response(HTTPStatus.NOT_FOUND)
return {"data": MessageSchema().dump(data)}, HTTPStatus.OK
def create_user(**kwargs):
user = User(
name=kwargs['name'],
description=kwargs['description'],
email=kwargs['email'],
create_at=kwargs['create_at'],
password=kwargs['password'],
user_type=kwargs['user_type']
)
try:
db.session.add(user)
db.session.commit()
return build_api_response(HTTPStatus.CREATED)
except IntegrityError:
return build_api_response(HTTPStatus.BAD_REQUEST)
def get(dog_id: int):
dog = Dog.query.get(dog_id)
if not dog:
return build_api_response(HTTPStatus.NOT_FOUND)
return {'data': dog_schema.dump(dog)}, HTTPStatus.OK
def list_one_product(product_id: int):
product = Product.query.get(product_id)
if not product:
return build_api_response(HTTPStatus.NOT_FOUND)
return {'data': ProductSchema().dump(product)}
def get_category(category_id):
category = Category.query.filter_by(id=category_id).first()
if category == None:
return build_api_response(404)
return category_schema.jsonify(category)
def login():
user_found = User.query.filter_by(email=request.get_json(
force=True).get('email')).first()
pwd_informed = user_found.password
pwd_db = request.get_json(force=True).get('password')
if pwd_informed != pwd_db:
return build_api_response(HTTPStatus.UNAUTHORIZED)
access_token = create_access_token(identity=user_found.id,
expires_delta=timedelta(days=5))
fresh_token = create_refresh_token(identity=user_found.id,
expires_delta=timedelta(days=10))
return {
'data': {
'name': user_found.name,
'email': user_found.email,
'is_admin': user_found.is_admin,
'access_token': access_token,
'fresh_token': fresh_token
}
}
def create_category():
data = request.get_json()
category = Category(name=data['name'], )
db.session.add(category)
db.session.commit()
return build_api_response(HTTPStatus.OK)
def signup():
data = request.get_json(force=True)
user = User(name=data.get('name', None),
email=data.get('email', None),
password=data.get('password', None),
is_admin=data.get('is_admin', None))
try:
db.session.add(user)
db.session.commit()
return build_api_response(HTTPStatus.CREATED)
except IntegrityError:
return build_api_response(HTTPStatus.UNPROCESSABLE_ENTITY)
def delete():
owner_id = get_jwt_identity()
Owner.query.get_or_404(owner_id)
Owner.query.filter_by(id=owner_id).delete()
db.session.commit()
return build_api_response(HTTPStatus.OK)
def create():
data = request.get_json()
user = User(
name=data["name"],
description=data['description'],
email=data['email'],
password=hashlib.sha256(data['password'].encode('utf-8')).hexdigest(),
create_at=datetime.now().astimezone(fuso_horario).strftime(
'%d/%m/%Y %H:%M:%S'),
)
try:
db.session.add(user)
db.session.commit()
return build_api_response(HTTPStatus.CREATED)
except IntegrityError:
return build_api_response(HTTPStatus.BAD_REQUEST)
def create_one_product():
data = request.get_json()
if not data:
return build_api_response(HTTPStatus.NOT_FOUND)
product = Product(name=data['name'],
price=data['price'],
description=data['description'],
image=data['image'],
category_id=data['category_id'])
try:
db.session.add(product)
db.session.commit()
return build_api_response(HTTPStatus.CREATED)
except IntegrityError:
return build_api_response(HTTPStatus.BAD_REQUEST)
def get_user():
user_id = get_jwt_identity()
if User.query.filter_by(id=user_id).first() is not None:
user = User.query.filter_by(id=user_id).first()
else:
return build_api_response(HTTPStatus.NOT_FOUND)
return {'data': serialize_user(user)}, HTTPStatus.OK
def delete():
owner_id = get_jwt_identity()
Owner.query.get_or_404(owner_id)
delete_all_owner_relationships(owner_id)
db.session.commit()
return build_api_response(HTTPStatus.OK)
def get_all_conversations(dog_id):
owner_id = get_jwt_identity()
found = Dog.query.filter_by(owner_id=owner_id, id=dog_id).first()
if not found:
return build_api_response(HTTPStatus.NOT_FOUND)
data = Conversation.query.filter(Conversation.dogs.any(id=dog_id)).all()
return {'data': ConversationSchema(many=True).dump(data)}, HTTPStatus.FOUND
def create():
owner_id = get_jwt_identity()
data = request.get_json()
current_owner = get_jwt_identity()
if current_owner is not data['owner_id']:
return build_api_response(HTTPStatus.UNAUTHORIZED)
dog = Dog(name=data['name'],
details=data['details'],
owner_id=owner_id,
breed_id=data['breed_id'],
gender=data['gender'])
try:
db.session.add(dog)
db.session.commit()
return build_api_response(HTTPStatus.CREATED)
except IntegrityError:
return build_api_response(HTTPStatus.BAD_REQUEST)
def delete_category(category_id: int):
category = Category.query.filter_by(id=category_id).first()
if category == None:
return build_api_response(404)
current_app.db.session.delete(category)
current_app.db.session.commit()
return {'message': 'Deleted'}, HTTPStatus.OK
