def put(self):
json = request.get_json()
parser = reqparse.RequestParser()
parser.add_argument('Magic-key', type=int, location='headers')
parser.add_argument('tea_id', type=int, location='args')
tea_id = parser.parse_args().get('tea_id')
magic_key = parser.parse_args().get('Magic-key')
if magic_key not in [1]:
return Error.getError(401, "Unauthorized")
tea = TeaModel.query.filter_by(id=tea_id).one_or_none()
if tea == None:
return Error.getError(404, "Tea not found")
tea.country = json['country']
tea.descryption = json['descryption']
tea.name = json['name']
tea.stock = json['stock']
tea.price = json['price']
tea.tea_type = json['teaType']
try:
db.session.add(tea)
db.session.commit()
except Exception as e:
return Error.getError(500, "Internal server eroror in database while adding tea")
response = jsonify(tea.serialize())
response.status_code = 200
return response
def post(self):
json = request.get_json()
user = UserModel()
if 'loginOrEmail' in json:
user = UserModel.query.filter(
or_(UserModel.login == json['loginOrEmail'],
UserModel.email == json['loginOrEmail'])).one_or_none()
if user == None:
return Error.getError(401, "WrOnG LoGiN oR eMaIl!")
else:
return Error.getError(
400,
"How can I find user, when you not give login or name??????????"
)
if 'password' in json:
if json['password'] != user.password:
return Error.getError(401, "Bad password, silly tiny hacker!")
else:
return Error.getError(
400,
"Ok, I have a user, but now I need a password! I should made a limit for dump requests!!!"
)
response = jsonify({
'key': user.user_type.id,
'userType': user.user_type.user_type_name,
"userId": user.id
})
response.status_code = 200
return response
def put(self):
parser = reqparse.RequestParser()
parser.add_argument('order_id', type=int, location='args')
parser.add_argument('Magic-key', type=int, location='headers')
magic_key = parser.parse_args().get('Magic-key')
if magic_key not in [1, 2]:
return Error.getError(401, "Unauthorized")
order_id = parser.parse_args().get('order_id')
order = OrderModel.query.filter_by(id=order_id).one_or_none()
if order == None:
return Error.getError(404, "Order not found")
json = request.get_json()
order.status_id = json['status']
try:
db.session.add(order)
db.session.commit()
except Exception:
return Error.getError(
500, "Like others u know server database workin niht bleble")
response = jsonify(order.serialize())
response.status_code = 200
return response
def post(self):
json = request.get_json()
parser = reqparse.RequestParser()
parser.add_argument('Magic-key', type=int, location='headers')
magic_key = parser.parse_args().get('Magic-key')
print(magic_key)
if magic_key not in [1]:
return Error.getError(401, "Unauthorized")
tea = TeaModel()
tea.country = json['country']
tea.descryption = json['descryption']
tea.name = json['name']
tea.stock = json['stock']
tea.price = json['price']
tea.tea_type = json['teaType']
tea.photo_id = random.randrange(1, 8)
try:
db.session.add(tea)
db.session.commit()
except Exception as e:
#print(e)
return Error.getError(500, "Internal server eroror in database while adding tea")
response = jsonify(tea.serialize())
response.status_code = 200
return response
def delete(self):
parser = reqparse.RequestParser()
parser.add_argument('Magic-key', type=int, location='headers')
parser.add_argument('tea_id', type=int, location='args')
tea_id = parser.parse_args().get('tea_id')
magic_key = parser.parse_args().get('Magic-key')
if magic_key not in [1]:
return Error.getError(401, "Unauthorized")
tea = TeaModel.query.filter_by(id=tea_id).one_or_none()
if tea == None:
return Error.getError(404, "Tea not found")
try:
db.session.delete(tea)
db.session.commit()
except Exception as e:
return Error.getError(500, "Internal server eroror in database while adding tea")
response = Response()
response.status_code = 200
return response
def put(self):
parser = reqparse.RequestParser()
parser.add_argument('user_id', type=int, location='args')
user_id = parser.parse_args().get('user_id')
user = UserModel.query.filter_by(id=user_id).one_or_none()
if user == None:
return Error.getError(404, "Users not found")
json = request.get_json()
user.email = json['email']
user.login = json['login']
user.password = json['password']
user.user_type = json['user_type']
try:
db.session.add(user)
db.session.commit()
except Exception:
return Error.getError(500, "Internal server eroror in database while vladimir PUTin user")
response = jsonify(user.serialize())
response.status_code = 200
return response
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('Magic-key', type=int, location='headers')
magic_key = parser.parse_args().get('Magic-key')
if magic_key not in [1, 2]:
return Error.getError(401, "Unauthorized")
json = request.get_json()
order = OrderModel()
order.details = json['details']
order.status_id = json['status']
address = AddressModel()
json_address = json['address']
if 'id' in json_address:
address = AddressModel.query.filter_by(
id=json_address['id']).one_or_none()
if address == None:
return Error.getError(404, "Address not found")
else:
address.number = json_address['number']
address.city = json_address['city']
address.country = json_address['country']
address.street = json_address['street']
address.postal_code = json_address['postal_code']
try:
db.session.add(address)
except Exception:
return Error.getError(500, "Error databse address... TMI")
order.address = address
user = UserModel.query.filter_by(id=json['orderedBy']).one_or_none()
if user == None:
return Error.getError(404, "User not found")
order.ordered_by = [user]
order.ordered_teas = []
#[order.teas.append(TeaModel.query.filter_by(id=tea_id).one_or_none()) for tea_id in json['teaIds']]
for ordered_tea_json in json['orderedTeas']:
ordered_tea = OrderedTeas()
ordered_tea.tea_id = ordered_tea_json["teaId"]
ordered_tea.quantity = ordered_tea_json["quantity"]
order.ordered_teas.append(ordered_tea)
try:
db.session.add(order)
db.session.commit()
except Exception:
return Error.getError(500, "Internal server error i'm tired")
response = jsonify(order.serialize())
response.status_code = 200
return response
def put(self, tea_id):
parser = reqparse.RequestParser()
parser.add_argument('file',
type=werkzeug.datastructures.FileStorage,
location='files')
parser.add_argument('Magic-key', type=int, location='headers')
magic_key = parser.parse_args().get('Magic-key')
if magic_key not in [1]:
return Error.getError(401, "Unauthorized")
args = parser.parse_args()
file = args['file']
tea = TeaModel.query.filter_by(id=tea_id).one_or_none()
if tea == None:
return Error.getError(404, "Tea not found")
print(file)
try:
file.save(os.path.relpath('photo_store' + '/' + file.filename))
except Exception:
return Error.getError(
500, "Internal server fuckup whuile saving photo on disk")
teaPhoto = PhotoModel()
teaPhoto.path = 'photo_store' + '/' + file.filename
try:
db.session.add(teaPhoto)
db.session.commit()
except Exception as e:
return Error.getError(
500, "Internal server fuckup while saving photo in database")
tea.photo_id = teaPhoto.id
try:
db.session.add(tea)
db.session.commit()
except Exception as e:
return Error.getError(
500, "Internal server fuckup whuile saving tea in database")
response = jsonify(tea.serialize())
response.status_code = 200
return response
def get(self, tea_id):
tea = TeaModel.query.filter_by(id=tea_id).one_or_none()
if tea == None:
return Error.getError(404, "Tea not found")
return flask.send_file(os.path.abspath(tea.photo.path),
as_attachment=False)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('order_id', type=int, location='args')
parser.add_argument('Magic-key', type=int, location='headers')
magic_key = parser.parse_args().get('Magic-key')
if magic_key not in [1, 2]:
return Error.getError(401, "Unauthorized")
order_id = parser.parse_args().get('order_id')
order = OrderModel.query.filter_by(id=order_id).one_or_none()
if order == None:
return Error.getError(404, "Order not found")
response = jsonify(order.serialize())
response.status_code = 200
return response
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('tea_id', type=int, location='args')
tea_id = parser.parse_args().get('tea_id')
user = TeaModel.query.filter_by(id=tea_id).one_or_none()
if user == None:
return Error.getError(404, "Tea not found")
response = jsonify(user.serialize())
response.status_code = 200
return response
def post(self):
json = request.get_json()
user = UserModel()
user.email = json['email']
user.login = json['login']
user.password = json['password']
if UserModel.query.filter(UserModel.login == json['login']).first():
return Error.getError(409, "login not unique")
if UserModel.query.filter(UserModel.email == json['email']).first():
return Error.getError(409, "email not unique")
user_type = UserTypeModel.query.filter_by(id=json['user_type']).one_or_none()
if user_type == None:
return Error.getError(404, "UserType not found")
user.user_type = user_type
address = AddressModel()
json_address = json['default_address']
if 'id' in json_address:
address = AddressModel.query.filter_by(id=json_address['id']).one_or_none()
if address == None:
return Error.getError(404, "Address not found")
else:
address.number = json_address['number']
address.city = json_address['city']
address.country = json_address['country']
address.street = json_address['street']
address.postal_code = json_address['postal_code']
try:
db.session.add(address)
except Exception:
return Error.getError(500, "Internal server eroror in database while adding user address")
user.address = address
try:
db.session.add(user)
db.session.commit()
except Exception as e:
print(e)
return Error.getError(500, "Internal server eroror in database while adding user")
response = jsonify(user.serialize())
response.status_code = 201
return response
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('Magic-key', type=int, location='headers')
magic_key = parser.parse_args().get('Magic-key')
if magic_key not in [1, 2]:
return Error.getError(401, "Unauthorized")
parser = reqparse.RequestParser()
parser.add_argument('orderedBy', type=int, location='args')
parser.add_argument('pageNumber', type=int, location='args')
parser.add_argument('sortBy', type=str, location='args')
parser.add_argument('sortDirection', type=str, location='args')
ordered_by_id = parser.parse_args().get('orderedBy')
per_page = parser.parse_args().get('perPage')
page_number = parser.parse_args().get('pageNumber')
sort_by = parser.parse_args().get('sortBy')
sort_dir = parser.parse_args().get(
'sortDirection') if parser.parse_args().get('sortDirection') in [
'inc', 'desc'
] else 'inc'
order_name = {
'id': OrderModel.id,
'status': OrderModel.status,
}
order_query = None
if sort_by in order_name:
order_query = {
'inc': order_name[sort_by],
'desc': desc(order_name[sort_by])
}[sort_dir]
orders_paginator = None
if ordered_by_id is not None:
ordered_by = UserModel.query.filter_by(
id=ordered_by_id).one_or_none()
if ordered_by == None:
return Error.getError(404, "Order not found")
orders_paginator = OrderModel.query.filter(OrderModel.ordered_by.contains(ordered_by)) \
.order_by(order_query) \
.paginate(page=page_number, per_page=per_page, error_out=False, max_per_page=1500)
else:
orders_paginator = OrderModel.query.filter() \
.order_by(order_query) \
.paginate(page=page_number, per_page=per_page, error_out=False, max_per_page=1500)
orders = []
[orders.append(order.serialize()) for order in orders_paginator.items]
resDic = {
'page': orders_paginator.page,
'pages': orders_paginator.pages,
'perPage': orders_paginator.per_page,
'hasNext': orders_paginator.has_next,
'hasPrev': orders_paginator.has_prev,
'total': orders_paginator.total,
'itemsNumber': len(orders),
'items': orders
}
response = jsonify(resDic)
response.status_code = 200
return response
