def delete(id):
""" Delete one dish by id.
Method: *DELETE*
URI: */dishes/id*
"""
# Query
query = db.session.query(Dish)
dish = query.get(id)
# Check dish
if dish is None:
return make_response(gettext(u"Le plat n'existe pas."), 404)
# Delete dish
db.session.delete(dish)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dû a une erreur inconnue, le plat ne peut pas être supprimé."), 500)
# Build the response
response = make_response(jsonify(dish.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one order by id.
Method: *DELETE*
URI: */orders/id*
"""
# Query
query = db.session.query(Order).options(lazyload('*'))
order = query.get(id)
# Check menu
if order is None:
return make_response(gettext(u"La commande n'existe pas."), 404)
# Delete menu
db.session.delete(order)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe a une erreur inconnu, la commande ne peut pas être supprimée."
), 500)
# Build the response
response = make_response(
jsonify(order.to_dict(lines_order=False, state=False)))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one address by id.
Method: *DELETE*
URI: */address/id*
"""
# Query
query = db.session.query(Address)
address = query.get(id)
# Check client
if address is None:
return make_response(gettext(u"L'adresse n'existe pas."), 404)
# Unlink from country
address.country = None
# Delete address
db.session.delete(address)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe à une erreur inconnu, le client ne peut pas être supprimé."), 500)
# Build the response
response = make_response(jsonify(address.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one dish by id.
Method: *DELETE*
URI: */dishes/id*
"""
# Query
query = db.session.query(Dish)
dish = query.get(id)
# Check dish
if dish is None:
return make_response(gettext(u"Le plat n'existe pas."), 404)
# Delete dish
db.session.delete(dish)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dû a une erreur inconnue, le plat ne peut pas être supprimé."
), 500)
# Build the response
response = make_response(jsonify(dish.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one restaurant by id.
Method: *DELETE*
URI: */restaurants/id*
"""
# Query
query = db.session.query(Restaurant)
restaurant = query.get(id)
# Check restaurant
if restaurant is None:
return make_response(gettext(u"Le restaurant n'existe pas."), 404)
# Unlink restaurateur from restaurant
restaurant.restaurateur = None
# Delete restaurant
db.session.delete(restaurant)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe a une erreur inconnu, le restaurant ne peut pas être supprime."), 500)
# Build the response
response = make_response(jsonify(restaurant.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one order by id.
Method: *DELETE*
URI: */orders/id*
"""
# Query
query = db.session.query(Order).options(lazyload('*'))
order = query.get(id)
# Check menu
if order is None:
return make_response(gettext(u"La commande n'existe pas."), 404)
# Delete menu
db.session.delete(order)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe a une erreur inconnu, la commande ne peut pas être supprimée."), 500)
# Build the response
response = make_response(jsonify(order.to_dict(lines_order=False, state=False)))
response.status_code = 200
response.mimetype = 'application/json'
return response
def update(id):
""" Update menu
Method: *PUT*
URI: */menus/id*
"""
# Get request values
datas = request.values
# Check menu
menu = db.session.query(Menu).get(id)
if menu is None:
return make_response(gettext(u"Le menu n'existe pas."), 404)
# Check name
if 'name' in datas:
if not isinstance(datas['name'], (str, unicode)):
return make_response(gettext(u"Le nom du menu doit être une chaine de caractère."), 400)
menu.name = datas['name']
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe a une erreur inconnu, le menu ne peut pas être modifie."), 500)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one restaurateur by id.
Method: *DELETE*
URI: */restaurateurs/id*
"""
# Query
query = db.session.query(Restaurateur)
restaurateur = query.get(id)
# Check restaurateur
if restaurateur is None:
return make_response(gettext(u"Le restaurateur n'existe pas."), 404)
# Unlink from country
restaurateur.country = None
# Delete restaurateur
db.session.delete(restaurateur)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe à une erreur inconnu, le restaurateur ne peut pas être supprimé."), 500)
# Build the response
response = make_response(jsonify(restaurateur.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one menu by id.
Method: *DELETE*
URI: */menus/id*
"""
# Query
query = db.session.query(Menu)
menu = query.get(id)
# Check menu
if menu is None:
return make_response(gettext(u"Le menu n'existe pas."), 404)
# Delete menu
db.session.delete(menu)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe a une erreur inconnu, le menu ne peut pas être supprime."), 500)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one livreur by id.
Method: *DELETE*
URI: */livreurs/id*
"""
# Query
query = db.session.query(Livreur)
livreur = query.get(id)
# Check livreur
if livreur is None:
return make_response(gettext(u"Le livreur n'existe pas."), 404)
# Unlink from country
livreur.country = None
# Delete livreur
db.session.delete(livreur)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe à une erreur inconnu, le livreur ne peut pas être supprimé."), 500)
# Build the response
response = make_response(jsonify(livreur.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one menu by id.
Method: *DELETE*
URI: */menus/id*
"""
# Query
query = db.session.query(Menu)
menu = query.get(id)
# Check menu
if menu is None:
return make_response(gettext(u"Le menu n'existe pas."), 404)
# Delete menu
db.session.delete(menu)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe a une erreur inconnu, le menu ne peut pas être supprime."
), 500)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def create():
""" Create dish
Method: *POST*
URI: */dishes*
"""
# Get request values
datas = request.values
# Check name
if 'name' not in datas:
return make_response(gettext(u"Le nom du plat est obligatoire."), 400)
if not isinstance(datas['name'], (str, unicode)):
return make_response(gettext(u"Le nom du plat doit être une chaine de caractère."), 400)
# Check name
if 'menu_id' not in datas:
return make_response(gettext(u"menu_id est obligatoire."), 400)
try:
menu_id = int(datas['menu_id'])
menu = db.session.query(Menu).get(menu_id)
if menu is None:
return make_response(gettext(u"Le menu n'existe pas."), 404)
except:
return make_response(gettext(u"menu_id doit être un identifiant."), 400)
# Check description
if not isinstance(datas['description'], (str, unicode)):
return make_response(gettext(u"La description du plat doit être une chaine de caractère."), 400)
# Check price
if 'price' not in datas:
return make_response(gettext(u"Le prix du plat est obligatoire."), 400)
if not isinstance(datas['price'], (float, int)):
return make_response(gettext(u"Le prix du plat doit être numerique."), 400)
if not datas['price'] >= 0:
return make_response(gettext(u"Le prix du plat doit être positif."), 400)
# Create dish
dish = Dish(name=datas['name'], description = datas['description'], price = datas['price'], menu_id=menu_id)
# Add dish
db.session.add(dish)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dû a une erreur inconnue, le plat ne peut pas être crée."), 500)
# Build the response
response = make_response(jsonify(dish.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response
def update(id):
""" Update dish
Method: *PUT*
URI: */dishes/id*
"""
# Get request values
datas = request.values
# Check dish
dish = db.session.query(Dish).get(id)
if dish is None:
return make_response(gettext(u"Le plat n'existe pas."), 404)
# Check name
if 'name' in datas:
if not isinstance(datas['name'], (str, unicode)):
return make_response(
gettext(u"Le nom du plat doit être une chaine de caractère."),
400)
dish.name = datas['name']
# Check description
if 'description' in datas:
if not isinstance(datas['description'], (str, unicode)):
return make_response(
gettext(
u"La description du plat doit être une chaine de caractère."
), 400)
dish.description = datas['description']
# Check price
if 'price' in datas:
if not isinstance(datas['price'], (float, int)):
return make_response(
gettext(u"Le prix du plat doit être numerique."), 400)
if not datas['price'] >= 0:
return make_response(
gettext(u"Le prix du plat doit être positif."), 400)
dish.price = datas['price']
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dû a une erreur inconnue, le plat ne peut pas être modifie."
), 500)
# Build the response
response = make_response(jsonify(dish.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def update(id):
""" Update an address by id
Method: *PUT*
URI: */address/id*
"""
# Get request values
datas = request.values
# Check address
address = db.session.query(Address).get(id)
if address is None:
return make_response(gettext(u"L'adresse n'existe pas."), 404)
# Check address
if 'address' in datas:
if not isinstance(datas['address'], (str, unicode)):
return make_response(gettext(u"L'adresse doit être une chaine de caractère."), 400)
address.address = datas['address']
# Check zipcode
if 'zipcode' in datas:
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(gettext(u"Le code postal doit être une chaine de caractère."), 400)
address.zipcode = datas['zipcode']
# Check city
if 'city' in datas:
if not isinstance(datas['city'], (str, unicode)):
return make_response(gettext(u"La ville doit être une chaine de caractère."), 400)
address.city = datas['city']
# Check country
if 'country_id' in datas:
try:
country_id = int(datas['country_id'])
except Exception: # pragma: no cover
return make_response(gettext(u"country_id doit être un identifiant."), 400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
address.country = country
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe à une erreur inconnu, l'adresse ne peut pas être modifiée."), 500)
# Build the response
response = make_response(jsonify(address.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return all orders.
Method: *GET*
URI: */orders*
Parameters: ?state=id
?client_id=id
?restaurant_id=id
0: En attente
1: En préparation
2: Prête
3: En cours de livraison
4: Livrée
"""
# Prepare query
query = db.session.query(Order)
# State
if 'state' in request.values:
try:
state_int = int(request.values['state'])
except:
return make_response(gettext(u"L'état doit être 0, 1, 2 ou 3."),
400)
states = {
0: u"En attente",
1: u"En préparation",
2: u"Prête",
3: u"En cours de livraison",
4: u"Livrée"
}
state = states[state_int]
query = query.join(StateOrder).filter(StateOrder.name == state)
if 'client_id' in request.values:
query = query.filter(Order.client_id == request.values['client_id'])
if 'restaurant_id' in request.values:
query = query.filter(
Order.restaurant_id == request.values['restaurant_id'])
orders = query.all()
# Build the response
response = make_response(jsonify([o.to_dict() for o in orders]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def create():
""" Create menu
Method: *POST*
URI: */menus*
"""
# Get request values
datas = request.values
# Check name
if 'name' not in datas:
return make_response(gettext(u"Le nom du menu est obligatoire."), 400)
if not isinstance(datas['name'], (str, unicode)):
return make_response(
gettext(u"Le nom du menu doit être une chaine de caractère."), 400)
# Check restaurant
if 'restaurant_id' not in datas:
return make_response(gettext(u"restaurant_id est obligatoire."), 400)
try:
restaurant_id = int(datas['restaurant_id'])
restaurant = db.session.query(Restaurant).get(restaurant_id)
if restaurant is None:
return make_response(gettext(u"Le restaurant n'existe pas."), 404)
except:
return make_response(
gettext(u"restaurant_id doit être un identifiant."), 400)
# Create menu
menu = Menu(name=datas['name'], restaurant_id=restaurant_id)
# Add menu
db.session.add(menu)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe a une erreur inconnu, le menu ne peut pas être cree."),
500)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response
def update(id):
""" Update dish
Method: *PUT*
URI: */dishes/id*
"""
# Get request values
datas = request.values
# Check dish
dish = db.session.query(Dish).get(id)
if dish is None:
return make_response(gettext(u"Le plat n'existe pas."), 404)
# Check name
if 'name' in datas:
if not isinstance(datas['name'], (str, unicode)):
return make_response(gettext(u"Le nom du plat doit être une chaine de caractère."), 400)
dish.name = datas['name']
# Check description
if 'description' in datas:
if not isinstance(datas['description'], (str, unicode)):
return make_response(gettext(u"La description du plat doit être une chaine de caractère."), 400)
dish.description = datas['description']
# Check price
if 'price' in datas:
if not isinstance(datas['price'], (float, int)):
return make_response(gettext(u"Le prix du plat doit être numerique."), 400)
if not datas['price'] >= 0:
return make_response(gettext(u"Le prix du plat doit être positif."), 400)
dish.price = datas['price']
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dû a une erreur inconnue, le plat ne peut pas être modifie."), 500)
# Build the response
response = make_response(jsonify(dish.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return all livreurs.
Method: *GET*
URI: */livreurs*
"""
# Query
query = db.session.query(Livreur)
livreurs = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in livreurs]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return all livreurs.
Method: *GET*
URI: */livreurs*
"""
# Query
query = db.session.query(Livreur)
livreurs = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in livreurs]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return all states_orders.
Method: *GET*
URI: */orders/states*
"""
# Query
query = db.session.query(StateOrder)
states_orders = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in states_orders]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return all countries.
Method: *GET*
URI: */countries*
"""
# Query
query = db.session.query(Country)
countries = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in countries]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return all countries.
Method: *GET*
URI: */countries*
"""
# Query
query = db.session.query(Country)
countries = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in countries]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def create():
""" Create menu
Method: *POST*
URI: */menus*
"""
# Get request values
datas = request.values
# Check name
if 'name' not in datas:
return make_response(gettext(u"Le nom du menu est obligatoire."), 400)
if not isinstance(datas['name'], (str, unicode)):
return make_response(gettext(u"Le nom du menu doit être une chaine de caractère."), 400)
# Check restaurant
if 'restaurant_id' not in datas:
return make_response(gettext(u"restaurant_id est obligatoire."), 400)
try:
restaurant_id = int(datas['restaurant_id'])
restaurant = db.session.query(Restaurant).get(restaurant_id)
if restaurant is None:
return make_response(gettext(u"Le restaurant n'existe pas."), 404)
except:
return make_response(gettext(u"restaurant_id doit être un identifiant."), 400)
# Create menu
menu = Menu(name=datas['name'], restaurant_id=restaurant_id)
# Add menu
db.session.add(menu)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe a une erreur inconnu, le menu ne peut pas être cree."), 500)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response
def list():
""" Return all orders.
Method: *GET*
URI: */orders*
Parameters: ?state=id
?client_id=id
?restaurant_id=id
0: En attente
1: En préparation
2: Prête
3: En cours de livraison
4: Livrée
"""
# Prepare query
query = db.session.query(Order)
# State
if 'state' in request.values:
try:
state_int = int(request.values['state'])
except:
return make_response(gettext(u"L'état doit être 0, 1, 2 ou 3."), 400)
states = {0: u"En attente", 1: u"En préparation", 2: u"Prête", 3: u"En cours de livraison", 4: u"Livrée"}
state = states[state_int]
query = query.join(StateOrder).filter(StateOrder.name == state)
if 'client_id' in request.values:
query = query.filter(Order.client_id == request.values['client_id'])
if 'restaurant_id' in request.values:
query = query.filter(Order.restaurant_id == request.values['restaurant_id'])
orders = query.all()
# Build the response
response = make_response(jsonify([o.to_dict() for o in orders]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one client by id.
Method: *GET*
URI: */clients/id*
"""
# Query
query = db.session.query(Client)
client = query.get(id)
# Check client
if client is None:
return make_response(gettext(u"Le client n'existe pas."), 400)
# Build the response
response = make_response(jsonify(client.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one address by id.
Method: *GET*
URI: */addresses/id*
"""
# Query
query = db.session.query(Address)
address = query.get(id)
# Check client
if address is None:
return make_response(gettext(u"L'adresse n'existe pas."), 400)
# Build the response
response = make_response(jsonify(address.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one livreur by id.
Method: *GET*
URI: */livreurs/id*
"""
# Query
query = db.session.query(Livreur)
livreur = query.get(id)
# Check livreur
if livreur is None:
return make_response(gettext(u"Le livreur n'existe pas."), 400)
# Build the response
response = make_response(jsonify(livreur.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one livreur by id.
Method: *GET*
URI: */livreurs/id*
"""
# Query
query = db.session.query(Livreur)
livreur = query.get(id)
# Check livreur
if livreur is None:
return make_response(gettext(u"Le livreur n'existe pas."), 400)
# Build the response
response = make_response(jsonify(livreur.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one address by id.
Method: *GET*
URI: */addresses/id*
"""
# Query
query = db.session.query(Address)
address = query.get(id)
# Check client
if address is None:
return make_response(gettext(u"L'adresse n'existe pas."), 400)
# Build the response
response = make_response(jsonify(address.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one country by id.
Method: *GET*
URI: */countries/id*
"""
# Query
query = db.session.query(Country)
country = query.get(id)
# Check country
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 400)
# Build the response
response = make_response(jsonify(country.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return addresses
Method: *GET*
URI: */addresses*
Params: ?personne_id=id
"""
# Query
query = db.session.query(Address)
if 'personne_id' in request.values:
query = query.filter(Address.personne_id == request.values['personne_id'])
addresses = query.all()
# Build the response
response = make_response(jsonify([a.to_dict() for a in addresses]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list(id):
""" Return all dishes for a menu.
Method: *GET*
URI: */menus/id/dishes*
"""
# Check menu id
if db.session.query(Menu).get(id) is None:
return make_response(gettext(u"Le menu n'existe pas."), 404)
# Query
query = db.session.query(Dish).filter(Dish.menu_id == id)
dishes = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in dishes]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list(id):
""" Return all menus for the specified restaurant.
Method: *GET*
URI: */restaurants/id/menus*
"""
# Check menu id
if db.session.query(Restaurant).get(id) is None:
return make_response(gettext(u"Le restaurant n'existe pas."), 404)
# Query
query = db.session.query(Menu).filter(Menu.restaurant_id == id)
menus = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in menus]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one order by id.
Method: *GET*
URI: */orders/id*
"""
# Query
query = db.session.query(Order)
order = query.get(id)
# Check menu
if order is None:
return make_response(gettext(u"La commande n'existe pas."), 400)
# Build the response
response = make_response(jsonify(order.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list(id):
""" Return all dishes for a menu.
Method: *GET*
URI: */menus/id/dishes*
"""
# Check menu id
if db.session.query(Menu).get(id) is None:
return make_response(gettext(u"Le menu n'existe pas."), 404)
# Query
query = db.session.query(Dish).filter(Dish.menu_id==id)
dishes = query.all()
# Build the response
response = make_response(jsonify([r.to_dict() for r in dishes]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one dish by id.
Method: *GET*
URI: */dishes/id*
"""
# Query
query = db.session.query(Dish)
dish = query.get(id)
# Check dish
if dish is None:
return make_response(gettext(u"Le plat n'existe pas."), 400)
# Build the response
response = make_response(jsonify(dish.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one menu by id.
Method: *GET*
URI: */menus/id*
"""
# Query
query = db.session.query(Menu)
menu = query.get(id)
# Check menu
if menu is None:
return make_response(gettext(u"Le menu n'existe pas."), 400)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one order by id.
Method: *GET*
URI: */orders/id*
"""
# Query
query = db.session.query(Order)
order = query.get(id)
# Check menu
if order is None:
return make_response(gettext(u"La commande n'existe pas."), 400)
# Build the response
response = make_response(jsonify(order.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one country by id.
Method: *GET*
URI: */countries/id*
"""
# Query
query = db.session.query(Country)
country = query.get(id)
# Check country
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 400)
# Build the response
response = make_response(jsonify(country.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one dish by id.
Method: *GET*
URI: */dishes/id*
"""
# Query
query = db.session.query(Dish)
dish = query.get(id)
# Check dish
if dish is None:
return make_response(gettext(u"Le plat n'existe pas."), 400)
# Build the response
response = make_response(jsonify(dish.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one menu by id.
Method: *GET*
URI: */menus/id*
"""
# Query
query = db.session.query(Menu)
menu = query.get(id)
# Check menu
if menu is None:
return make_response(gettext(u"Le menu n'existe pas."), 400)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def index(id):
""" Return one country by id.
Method: *GET*
URI: */orders/states/id*
"""
# Query
query = db.session.query(StateOrder)
so = query.get(id)
# Check country
if so is None:
return make_response(gettext(u"L'état n'existe pas."), 400)
# Build the response
response = make_response(jsonify(so.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def update(id):
""" Update menu
Method: *PUT*
URI: */menus/id*
"""
# Get request values
datas = request.values
# Check menu
menu = db.session.query(Menu).get(id)
if menu is None:
return make_response(gettext(u"Le menu n'existe pas."), 404)
# Check name
if 'name' in datas:
if not isinstance(datas['name'], (str, unicode)):
return make_response(
gettext(u"Le nom du menu doit être une chaine de caractère."),
400)
menu.name = datas['name']
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe a une erreur inconnu, le menu ne peut pas être modifie."
), 500)
# Build the response
response = make_response(jsonify(menu.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def list():
""" Return addresses
Method: *GET*
URI: */addresses*
Params: ?personne_id=id
"""
# Query
query = db.session.query(Address)
if 'personne_id' in request.values:
query = query.filter(
Address.personne_id == request.values['personne_id'])
addresses = query.all()
# Build the response
response = make_response(jsonify([a.to_dict() for a in addresses]))
response.status_code = 200
response.mimetype = 'application/json'
return response
def delete(id):
""" Delete one address by id.
Method: *DELETE*
URI: */address/id*
"""
# Query
query = db.session.query(Address)
address = query.get(id)
# Check client
if address is None:
return make_response(gettext(u"L'adresse n'existe pas."), 404)
# Unlink from country
address.country = None
# Delete address
db.session.delete(address)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe à une erreur inconnu, le client ne peut pas être supprimé."
), 500)
# Build the response
response = make_response(jsonify(address.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def authentication():
""" Create accesstoken
Method: *POST*
URI: */accesstokens*
"""
# Get request values
datas = request.values
# Check firstname
if 'mail' not in datas:
return make_response(gettext(u"L'adresse mail est obligatoire."), 400)
if not isinstance(datas['mail'], (str, unicode)):
return make_response(gettext(u"L'adresse mail doit être une chaine de caractère."), 400)
# Check lastname
if 'password' not in datas:
return make_response(gettext(u"Le mot de passe est obligatoire."), 400)
if not isinstance(datas['password'], (str, unicode)):
return make_response(gettext(u"Le mot de passe doit être une chaine de caractère."), 400)
try:
user = db.session.query(Personne).filter(Personne.mail==datas['mail']).filter(Personne.password==datas['password']).one()
except:
return make_response(gettext(u"Echec d'authentification, l'adresse mail ou le mot de passe ne correspondent a aucun utilisateur."), 404)
if not login_user(user): # pragma no cover
return make_response(gettext(u"Dûe à une erreur inconnu, il est impossible de vous connecter."), 404)
# Build the response
response = make_response(jsonify(user.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def create():
""" Create an order
Method: *POST*
URI: */orders*
"""
# Get request values
datas = request.values
# Check date
if 'date' not in datas:
return make_response(gettext(u"La date est obligatoire."), 400)
try:
date = datetime.datetime.strptime(datas['date'], '%Y-%m-%dT%H:%M:%S.%fZ')
except:
return make_response(gettext(u"Le format de la date est invalide."), 400)
# Check address
if 'address_id' not in datas:
return make_response(gettext(u"L'adresse de livraison est obligatoire."), 400)
try:
address_id = int(datas['address_id'])
except Exception:
return make_response(gettext(u"address_id doit être un identifiant."), 400)
address = db.session.query(Address).get(address_id)
if address is None:
return make_response(gettext(u"L'adresse n'existe pas."), 404)
# Check restaurant
if 'restaurant_id' not in datas:
return make_response(gettext(u"restaurant_id est obligatoire."), 400)
try:
restaurant_id = int(datas['restaurant_id'])
except Exception:
return make_response(gettext(u"restaurant_id doit être un identifiant."), 400)
restaurant = db.session.query(Restaurant).get(restaurant_id)
if restaurant is None:
return make_response(gettext(u"Le restaurant n'existe pas."), 404)
# Get client id from logged used
from flask.ext.login import current_user
if not hasattr(current_user, "id"):
return make_response(gettext(u"Vous ne pouvez pas passer de commander si vous n'êtes pas connecté."), 400)
# Get state "En attente"
try:
state = db.session.query(StateOrder).filter(StateOrder.name == "En attente").one()
except:
return make_response(gettext(u"L'état 'En attente' est inexistant."), 400)
# Create menu
# TODO: generate order number !
order = Order(number=1, date=date, client_id=current_user.id, state_id=state.id, address_id=address_id, restaurant_id=restaurant.id)
# Create line order
if 'dishes' not in datas:
return make_response(gettext(u"Une commande doit comporté au moins un plat."), 400)
for dish in datas['dishes']:
if 'dish_id' not in dish or 'quantity' not in dish:
return make_response(gettext(u"Une erreur s'est produite."), 400)
try:
quantity = int(dish['quantity'])
except:
return make_response(gettext(u"La quantité doit être un nombre entier."), 400)
try:
dish_id = int(dish['dish_id'])
except:
return make_response(gettext(u"dish_id doit être un identifiant."), 400)
order.lines_order.append(LineOrder(dish_id=dish_id, quantity=quantity))
# Add menu
db.session.add(order)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe a une erreur inconnu, la commande ne peut pas être créée."), 500)
# Build the response
response = make_response(jsonify(order.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response
def create():
""" Create an address
Method: *POST*
URI: */address*
"""
# Get request values
datas = request.values
# Check personne
if 'personne_id' not in datas:
return make_response(
gettext(u"L'identifiant d'une personne est obligatoire."), 400)
try:
personne_id = int(datas['personne_id'])
except Exception:
return make_response(gettext(u"personne_id doit être un identifiant."),
400)
personne = db.session.query(Personne).get(personne_id)
if personne is None:
return make_response(gettext(u"La personne n'existe pas."), 404)
# Check address
if 'address' not in datas:
return make_response(gettext(u"L'adresse est obligatoire."), 400)
if not isinstance(datas['address'], (str, unicode)):
return make_response(
gettext(u"L'adresse doit être une chaine de caractère."), 400)
# Check zipcode
if 'zipcode' not in datas:
return make_response(gettext(u"Le code postal est obligatoire."), 400)
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(
gettext(u"Le code postal doit être une chaine de caractère."), 400)
# Check city
if 'city' not in datas:
return make_response(gettext(u"La ville est obligatoire."), 400)
if not isinstance(datas['city'], (str, unicode)):
return make_response(
gettext(u"La ville doit être une chaine de caractère."), 400)
# Check country
if 'country_id' not in datas:
return make_response(gettext(u"Le pays est obligatoire."), 400)
try:
country_id = int(datas['country_id'])
except Exception:
return make_response(gettext(u"country_id doit être un identifiant."),
400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
# Create address
address = Address(address=datas['address'],
zipcode=datas['zipcode'],
city=datas['city'],
country=country,
personne_id=personne_id)
# Add address
db.session.add(address)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe à une erreur inconnu, l'adresse ne peut pas être créé."),
500)
# Build the response
response = make_response(jsonify(address.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response
def update(id):
""" Update livreur
Method: *PUT*
URI: */livreurs/id*
"""
# Get request values
datas = request.values
# Check livreur
livreur = db.session.query(Livreur).get(id)
if livreur is None:
return make_response(gettext(u"Le livreur n'existe pas."), 404)
# Check firstname
if 'firstname' in datas:
if not isinstance(datas['firstname'], (str, unicode)):
return make_response(
gettext(u"Le nom doit être une chaine de caractère."), 400)
livreur.firstname = datas['firstname']
# Check lastname
if 'lastname' in datas:
if not isinstance(datas['lastname'], (str, unicode)):
return make_response(
gettext(u"Le prénom doit être une chaine de caractère."), 400)
livreur.lastname = datas['lastname']
# Check password
if 'password' in datas:
if not isinstance(datas['password'], (str, unicode)):
return make_response(
gettext(u"Le mot de passe doit être une chaine de caractère."),
400)
livreur.password = datas['password']
# Check phone
if 'phone' in datas:
if not isinstance(datas['phone'], (str, unicode)):
return make_response(
gettext(
u"Le numéro de téléphone doit être une chaine de caractère."
), 400)
livreur.phone = datas['phone']
# Check address
if 'address' in datas:
if not isinstance(datas['address'], (str, unicode)):
return make_response(
gettext(u"L'adresse doit être une chaine de caractère."), 400)
livreur.address = datas['address']
# Check zipcode
if 'zipcode' in datas:
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(
gettext(u"Le code postal doit être une chaine de caractère."),
400)
livreur.zipcode = datas['zipcode']
# Check city
if 'city' in datas:
if not isinstance(datas['city'], (str, unicode)):
return make_response(
gettext(u"La ville doit être une chaine de caractère."), 400)
livreur.city = datas['city']
# Check language
if 'language' in datas:
if not isinstance(datas['language'], (str, unicode)):
return make_response(
gettext(u"La langue doit être une chaine de caractère."), 400)
livreur.language = datas['language']
# Check country
if 'country_id' in datas:
try:
country_id = int(datas['country_id'])
except Exception: # pragma: no cover
return make_response(
gettext(u"country_id doit être un identifiant."), 400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
livreur.country = country
# Check birthdate
if 'birthdate' in datas:
try:
birthdate = datetime.datetime.strptime(datas['birthdate'],
'%Y-%m-%dT%H:%M:%S.%fZ')
except:
return make_response(
gettext(u"Le format de la date est invalide."), 400)
livreur.birthdate = birthdate
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe à une erreur inconnu, le livreur ne peut pas être modifié."
), 500)
# Build the response
response = make_response(jsonify(livreur.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def update(id):
""" Update an address by id
Method: *PUT*
URI: */address/id*
"""
# Get request values
datas = request.values
# Check address
address = db.session.query(Address).get(id)
if address is None:
return make_response(gettext(u"L'adresse n'existe pas."), 404)
# Check address
if 'address' in datas:
if not isinstance(datas['address'], (str, unicode)):
return make_response(
gettext(u"L'adresse doit être une chaine de caractère."), 400)
address.address = datas['address']
# Check zipcode
if 'zipcode' in datas:
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(
gettext(u"Le code postal doit être une chaine de caractère."),
400)
address.zipcode = datas['zipcode']
# Check city
if 'city' in datas:
if not isinstance(datas['city'], (str, unicode)):
return make_response(
gettext(u"La ville doit être une chaine de caractère."), 400)
address.city = datas['city']
# Check country
if 'country_id' in datas:
try:
country_id = int(datas['country_id'])
except Exception: # pragma: no cover
return make_response(
gettext(u"country_id doit être un identifiant."), 400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
address.country = country
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe à une erreur inconnu, l'adresse ne peut pas être modifiée."
), 500)
# Build the response
response = make_response(jsonify(address.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def create():
""" Create livreur
Method: *POST*
URI: */livreurs*
"""
# Get request values
datas = request.values
# Check firstname
if 'firstname' not in datas:
return make_response(gettext(u"Le nom est obligatoire."), 400)
if not isinstance(datas['firstname'], (str, unicode)):
return make_response(gettext(u"Le nom doit être une chaine de caractère."), 400)
# Check lastname
if 'lastname' not in datas:
return make_response(gettext(u"Le prénom est obligatoire."), 400)
if not isinstance(datas['lastname'], (str, unicode)):
return make_response(gettext(u"Le prénom doit être une chaine de caractère."), 400)
# Check mail
if 'mail' not in datas:
return make_response(gettext(u"L'adresse mail est obligatoire."), 400)
if not isinstance(datas['mail'], (str, unicode)):
return make_response(gettext(u"L'adresse mail doit être une chaine de caractère."), 400)
if len(db.session.query(Personne).filter(Personne.mail == datas['mail']).all()) > 0:
return make_response(gettext(u"L'adresse mail est deja utilisee par un utilisateur."), 400)
# Check password
if 'password' not in datas:
return make_response(gettext(u"Le mot de passe est obligatoire."), 400)
if not isinstance(datas['password'], (str, unicode)):
return make_response(gettext(u"Le mot de passe doit être une chaine de caractère."), 400)
# Check phone
if 'phone' not in datas:
return make_response(gettext(u"Le numéro de téléphone est obligatoire."), 400)
if not isinstance(datas['phone'], (str, unicode)):
return make_response(gettext(u"Le numéro de téléphone doit être une chaine de caractère."), 400)
# Check address
if 'address' not in datas:
return make_response(gettext(u"L'adresse est obligatoire."), 400)
if not isinstance(datas['address'], (str, unicode)):
return make_response(gettext(u"L'adresse doit être une chaine de caractère."), 400)
# Check zipcode
if 'zipcode' not in datas:
return make_response(gettext(u"Le code postal est obligatoire."), 400)
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(gettext(u"Le code postal doit être une chaine de caractère."), 400)
# Check city
if 'city' not in datas:
return make_response(gettext(u"La ville est obligatoire."), 400)
if not isinstance(datas['city'], (str, unicode)):
return make_response(gettext(u"La ville doit être une chaine de caractère."), 400)
# Check country
if 'country_id' not in datas:
return make_response(gettext(u"Le pays est obligatoire."), 400)
try:
country_id = int(datas['country_id'])
except Exception:
return make_response(gettext(u"country_id doit être un identifiant."), 400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
# Create livreur
livreur = Livreur(firstname=datas['firstname'], lastname=datas['lastname'], phone=datas['phone'], address=datas['address'], zipcode=datas['zipcode'], city=datas['city'], country=country, mail=datas['mail'], password=datas['password'])
db.session.flush()
livreur.create_order_address()
# Check birthdate
if 'birthdate' in datas:
try:
birthdate = datetime.datetime.strptime(datas['birthdate'], '%Y-%m-%dT%H:%M:%S.%fZ')
except:
return make_response(gettext(u"Le format de la date est invalide."), 400)
livreur.birthdate = birthdate
# Add livreur
db.session.add(livreur)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe à une erreur inconnu, le livreur ne peut pas être créé."), 500)
# Build the response
response = make_response(jsonify(livreur.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response
def update(id):
""" Update restaurant
Method: *PUT*
URI: */restaurants/id*
"""
# Get request values
datas = request.values
# Check restaurant
restaurant = db.session.query(Restaurant).get(id)
if restaurant is None:
return make_response(gettext(u"Le restaurant n'existe pas."), 400)
# Check name
if 'name' in datas:
if not isinstance(datas['name'], (str, unicode)):
return make_response(
gettext(u"Le nom doit être une chaine de caractère."), 400)
restaurant.name = datas['name']
# Check city
if 'city' in datas:
if not isinstance(datas['city'], (str, unicode)):
return make_response(
gettext(u"La ville doit être une chaine de caractère."), 400)
restaurant.city = datas['city']
# Check address
if 'address' in datas:
if not isinstance(datas['address'], (str, unicode)):
return make_response(
gettext(u"L'adresse doit être une chaine de caractère."), 400)
restaurant.address = datas['address']
# Check phone
if 'phone' in datas:
if not isinstance(datas['phone'], (str, unicode)):
return make_response(
gettext(
u"Le numéro de téléphone doit être une chaine de caractère."
), 400)
restaurant.phone = datas['phone']
# Check zipcode
if 'zipcode' in datas:
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(
gettext(u"Le code postal doit être une chaine de caractère."),
400)
restaurant.zipcode = datas['zipcode']
# Check country
if 'country_id' in datas:
try:
country_id = int(datas['country_id'])
except Exception: # pragma: no cover
return make_response(
gettext(u"country_id doit être un identifiant."), 400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
restaurant.country = country
else:
restaurant.country = None
# Check restaurateur
if 'restaurateur_id' in datas:
try:
restaurateur_id = int(datas['restaurateur_id'])
except Exception: # pragma: no cover
return make_response(
gettext(u"restaurateur_id doit être un identifiant."), 400)
restaurateur = db.session.query(Restaurateur).get(restaurateur_id)
if restaurateur is None:
return make_response(gettext(u"Le restaurateur n'existe pas."),
404)
if restaurateur.restaurant is not None:
if restaurateur.restaurant.id != restaurant.id:
return make_response(
gettext(
u"Le restaurateur est deja assigné a un restaurant."),
400)
restaurant.restaurateur = restaurateur
else:
restaurant.restaurateur = None
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe a une erreur inconnu, le restaurant ne peut pas être modifie."
), 500)
# Build the response
response = make_response(jsonify(restaurant.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def update(id):
""" Update livreur
Method: *PUT*
URI: */livreurs/id*
"""
# Get request values
datas = request.values
# Check livreur
livreur = db.session.query(Livreur).get(id)
if livreur is None:
return make_response(gettext(u"Le livreur n'existe pas."), 404)
# Check firstname
if 'firstname' in datas:
if not isinstance(datas['firstname'], (str, unicode)):
return make_response(gettext(u"Le nom doit être une chaine de caractère."), 400)
livreur.firstname = datas['firstname']
# Check lastname
if 'lastname' in datas:
if not isinstance(datas['lastname'], (str, unicode)):
return make_response(gettext(u"Le prénom doit être une chaine de caractère."), 400)
livreur.lastname = datas['lastname']
# Check password
if 'password' in datas:
if not isinstance(datas['password'], (str, unicode)):
return make_response(gettext(u"Le mot de passe doit être une chaine de caractère."), 400)
livreur.password = datas['password']
# Check phone
if 'phone' in datas:
if not isinstance(datas['phone'], (str, unicode)):
return make_response(gettext(u"Le numéro de téléphone doit être une chaine de caractère."), 400)
livreur.phone = datas['phone']
# Check address
if 'address' in datas:
if not isinstance(datas['address'], (str, unicode)):
return make_response(gettext(u"L'adresse doit être une chaine de caractère."), 400)
livreur.address = datas['address']
# Check zipcode
if 'zipcode' in datas:
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(gettext(u"Le code postal doit être une chaine de caractère."), 400)
livreur.zipcode = datas['zipcode']
# Check city
if 'city' in datas:
if not isinstance(datas['city'], (str, unicode)):
return make_response(gettext(u"La ville doit être une chaine de caractère."), 400)
livreur.city = datas['city']
# Check language
if 'language' in datas:
if not isinstance(datas['language'], (str, unicode)):
return make_response(gettext(u"La langue doit être une chaine de caractère."), 400)
livreur.language = datas['language']
# Check country
if 'country_id' in datas:
try:
country_id = int(datas['country_id'])
except Exception: # pragma: no cover
return make_response(gettext(u"country_id doit être un identifiant."), 400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
livreur.country = country
# Check birthdate
if 'birthdate' in datas:
try:
birthdate = datetime.datetime.strptime(datas['birthdate'], '%Y-%m-%dT%H:%M:%S.%fZ')
except:
return make_response(gettext(u"Le format de la date est invalide."), 400)
livreur.birthdate = birthdate
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(gettext(u"Dûe à une erreur inconnu, le livreur ne peut pas être modifié."), 500)
# Build the response
response = make_response(jsonify(livreur.to_dict()))
response.status_code = 200
response.mimetype = 'application/json'
return response
def create():
""" Create livreur
Method: *POST*
URI: */livreurs*
"""
# Get request values
datas = request.values
# Check firstname
if 'firstname' not in datas:
return make_response(gettext(u"Le nom est obligatoire."), 400)
if not isinstance(datas['firstname'], (str, unicode)):
return make_response(
gettext(u"Le nom doit être une chaine de caractère."), 400)
# Check lastname
if 'lastname' not in datas:
return make_response(gettext(u"Le prénom est obligatoire."), 400)
if not isinstance(datas['lastname'], (str, unicode)):
return make_response(
gettext(u"Le prénom doit être une chaine de caractère."), 400)
# Check mail
if 'mail' not in datas:
return make_response(gettext(u"L'adresse mail est obligatoire."), 400)
if not isinstance(datas['mail'], (str, unicode)):
return make_response(
gettext(u"L'adresse mail doit être une chaine de caractère."), 400)
if len(
db.session.query(Personne).filter(
Personne.mail == datas['mail']).all()) > 0:
return make_response(
gettext(u"L'adresse mail est deja utilisee par un utilisateur."),
400)
# Check password
if 'password' not in datas:
return make_response(gettext(u"Le mot de passe est obligatoire."), 400)
if not isinstance(datas['password'], (str, unicode)):
return make_response(
gettext(u"Le mot de passe doit être une chaine de caractère."),
400)
# Check phone
if 'phone' not in datas:
return make_response(
gettext(u"Le numéro de téléphone est obligatoire."), 400)
if not isinstance(datas['phone'], (str, unicode)):
return make_response(
gettext(
u"Le numéro de téléphone doit être une chaine de caractère."),
400)
# Check address
if 'address' not in datas:
return make_response(gettext(u"L'adresse est obligatoire."), 400)
if not isinstance(datas['address'], (str, unicode)):
return make_response(
gettext(u"L'adresse doit être une chaine de caractère."), 400)
# Check zipcode
if 'zipcode' not in datas:
return make_response(gettext(u"Le code postal est obligatoire."), 400)
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(
gettext(u"Le code postal doit être une chaine de caractère."), 400)
# Check city
if 'city' not in datas:
return make_response(gettext(u"La ville est obligatoire."), 400)
if not isinstance(datas['city'], (str, unicode)):
return make_response(
gettext(u"La ville doit être une chaine de caractère."), 400)
# Check country
if 'country_id' not in datas:
return make_response(gettext(u"Le pays est obligatoire."), 400)
try:
country_id = int(datas['country_id'])
except Exception:
return make_response(gettext(u"country_id doit être un identifiant."),
400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
# Create livreur
livreur = Livreur(firstname=datas['firstname'],
lastname=datas['lastname'],
phone=datas['phone'],
address=datas['address'],
zipcode=datas['zipcode'],
city=datas['city'],
country=country,
mail=datas['mail'],
password=datas['password'])
db.session.flush()
livreur.create_order_address()
# Check birthdate
if 'birthdate' in datas:
try:
birthdate = datetime.datetime.strptime(datas['birthdate'],
'%Y-%m-%dT%H:%M:%S.%fZ')
except:
return make_response(
gettext(u"Le format de la date est invalide."), 400)
livreur.birthdate = birthdate
# Add livreur
db.session.add(livreur)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe à une erreur inconnu, le livreur ne peut pas être créé."
), 500)
# Build the response
response = make_response(jsonify(livreur.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response
def create():
""" Create restaurant
Method: *POST*
URI: */restaurants*
"""
# Get request values
datas = request.values
# Check name
if 'name' not in datas:
return make_response(gettext(u"Le nom du restaurant est obligatoire."),
400)
if not isinstance(datas['name'], (str, unicode)):
return make_response(
gettext(u"Le nom doit être une chaine de caractère."), 400)
# Create restaurant
restaurant = Restaurant(name=datas['name'])
# Check phone
if 'phone' in datas:
if not isinstance(datas['phone'], (str, unicode)):
return make_response(
gettext(
u"Le numéro de téléphone doit être une chaine de caractère."
), 400)
restaurant.phone = datas['phone']
# Check cooking type
if 'cooking_type' in datas:
if not isinstance(datas['cooking_type'], (str, unicode)):
return make_response(
gettext(
u"Le type de cuisine doit être une chaine de caractère."),
400)
restaurant.cooking_type = datas['cooking_type']
# Check address
if 'address' in datas:
if not isinstance(datas['address'], (str, unicode)):
return make_response(
gettext(u"L'adresse doit être une chaine de caractère."), 400)
restaurant.address = datas['address']
# Check zipcode
if 'zipcode' in datas:
if not isinstance(datas['zipcode'], (str, unicode)):
return make_response(
gettext(u"Le code postal doit être une chaine de caractère."),
400)
restaurant.zipcode = datas['zipcode']
# Check city
if 'city' in datas:
if not isinstance(datas['city'], (str, unicode)):
return make_response(
gettext(u"La ville doit être une chaine de caractère."), 400)
restaurant.city = datas['city']
# Check country
if 'country_id' in datas:
try:
country_id = int(datas['country_id'])
except Exception: # pragma: no cover
return make_response(
gettext(u"country_id doit être un identifiant."), 400)
country = db.session.query(Country).get(country_id)
if country is None:
return make_response(gettext(u"Le pays n'existe pas."), 404)
restaurant.country = country
# Check restaurateur
if 'restaurateur_id' in datas:
try:
restaurateur_id = int(datas['restaurateur_id'])
except Exception:
return make_response(
gettext(u"restaurateur_id doit être un identifiant."), 400)
restaurateur = db.session.query(Restaurateur).get(restaurateur_id)
if restaurateur is None:
return make_response(gettext(u"Le restaurateur n'existe pas."),
404)
restaurant.restaurateur = restaurateur
# Add restaurant
db.session.add(restaurant)
# Commit
try:
db.session.commit()
except Exception: # pragma: no cover
db.session.rollback()
return make_response(
gettext(
u"Dûe a une erreur inconnu, le restaurateur ne peut pas être créé."
), 500)
# Build the response
response = make_response(jsonify(restaurant.to_dict()))
response.status_code = 201
response.mimetype = 'application/json'
return response