def test_fails_when_is_digital_but_physical_venue(self, app):
# Given
digital_thing = create_product_with_thing_type(
thing_type=ThingType.JEUX_VIDEO, url='http://mygame.fr/offre')
offerer = create_offerer()
physical_venue = create_venue(offerer)
PcObject.save(physical_venue)
offer = create_offer_with_thing_product(physical_venue, digital_thing)
# When
with pytest.raises(ApiErrors) as errors:
PcObject.save(offer)
# Then
assert errors.value.errors['venue'] == [
'Une offre numérique doit obligatoirement être associée au lieu "Offre en ligne"'
]
def test_returns_20_if_one_booking_with_amount_10_and_quantity_2(
self, app):
# Given
user = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock(price=10, offer=offer)
booking = create_booking(user, stock, venue=venue, quantity=2)
PcObject.save(booking, deposit)
# When
total_amount_spent = get_total_amount_spent()
# Then
assert total_amount_spent == 20
def test_returns_national_thing_with_different_department(self, app):
# given
product = create_product_with_thing_type(thing_name='Lire un livre',
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer,
postal_code='34000',
departement_code='34')
offer = create_offer_with_thing_product(venue, product)
PcObject.save(offer)
query = Product.query.filter_by(name='Lire un livre')
# when
query = department_or_national_offers(query, ['93'])
# then
assert product in query.all()
def when_searching_by_keywords_and_distance(self, app):
# Given
user = create_user(email='*****@*****.**')
concert_offer13 = create_offer_with_event_product(
self.venue13,
event_name='Funky Concert de Gael Faye',
event_type=EventType.MUSIQUE)
concert_offer75 = create_offer_with_event_product(
self.venue75,
event_name='Funky Concert de Gael Faye',
event_type=EventType.MUSIQUE)
concert_offer973 = create_offer_with_event_product(
self.venue973, event_name='Kiwi', event_type=EventType.MUSIQUE)
event_occurrence13 = create_event_occurrence(
concert_offer13,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
event_occurrence75 = create_event_occurrence(
concert_offer75,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
event_occurrence973 = create_event_occurrence(
concert_offer973,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
recommendation13 = create_recommendation(concert_offer13, user)
recommendation75 = create_recommendation(concert_offer75, user)
recommendation973 = create_recommendation(concert_offer973, user)
stock13 = create_stock_from_event_occurrence(event_occurrence13)
stock75 = create_stock_from_event_occurrence(event_occurrence75)
stock973 = create_stock_from_event_occurrence(event_occurrence973)
PcObject.save(stock13, recommendation13, stock75, recommendation75,
stock973, recommendation973)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?distance=1&keywords=funky')
# Then
assert len(response.json) == 2
def test_returns_true_when_a_beneficiary_import_exist_with_status_created(
self, app):
# given
now = datetime.utcnow()
user1 = create_user(email='*****@*****.**', date_created=now)
beneficiary_import = create_beneficiary_import(
user1,
status=ImportStatus.CREATED,
demarche_simplifiee_application_id=123)
PcObject.save(beneficiary_import)
# when
result = is_already_imported(123)
# then
assert result is True
def test_find_all_offerer_reimbursement_details(self, app):
# Given
user = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500, source='public')
offerer1 = create_offerer()
user_offerer1 = create_user_offerer(user,
offerer1,
validation_token=None)
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer1, siret='12345678912346')
bank_information1 = create_bank_information(
id_at_providers='79387501900056', venue=venue1)
bank_information2 = create_bank_information(
id_at_providers='79387501900057', venue=venue2)
offer1 = create_offer_with_thing_product(
venue1,
url='https://host/path/{token}?offerId={offerId}&email={email}')
offer2 = create_offer_with_thing_product(venue2)
stock1 = create_stock_with_thing_offer(offerer=offerer1,
venue=venue1,
price=10)
stock2 = create_stock_with_thing_offer(offerer=offerer1,
venue=venue2,
price=11)
booking1 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEF',
is_used=True)
booking2 = create_booking(user, stock1, venue=venue1, token='ABCDEG')
booking3 = create_booking(user,
stock2,
venue=venue2,
token='ABCDEH',
is_used=True)
PcObject.save(deposit, booking1, booking2, booking3, user_offerer1,
bank_information1, bank_information2)
generate_new_payments()
# When
reimbursement_details = find_all_offerer_reimbursement_details(
offerer1.id)
# Then
assert len(reimbursement_details) == 2
def test_success_when_is_physical_and_physical_venue(self, app):
# Given
physical_thing = create_product_with_thing_type(
thing_type=ThingType.LIVRE_EDITION, url=None)
offerer = create_offerer()
physical_venue = create_venue(offerer,
is_virtual=False,
siret=offerer.siren + '12345')
PcObject.save(physical_venue)
offer = create_offer_with_thing_product(physical_venue, physical_thing)
# When
PcObject.save(physical_thing, offer)
# Then
assert offer.url is None
def test_fails_when_is_physical_but_venue_is_virtual(self, app):
# Given
physical_thing = create_product_with_thing_type(
thing_type=ThingType.JEUX_VIDEO, url=None)
offerer = create_offerer()
digital_venue = create_venue(offerer, is_virtual=True, siret=None)
PcObject.save(digital_venue)
offer = create_offer_with_thing_product(digital_venue, physical_thing)
# When
with pytest.raises(ApiErrors) as errors:
PcObject.save(offer)
# Then
assert errors.value.errors['venue'] == [
'Une offre physique ne peut être associée au lieu "Offre en ligne"'
]
def test_collect_application_details_for_each_application(self,
find_latest_sync_end_event,
get_application_details,
get_all_application_ids_for_procedure,
app):
# given
APPLICATION_ID_2 = 2
last_provider_sync = LocalProviderEvent()
last_provider_sync.date = datetime(2020, 1, 2)
find_latest_sync_end_event.return_value = last_provider_sync
get_all_application_ids_for_procedure.return_value = [self.APPLICATION_ID,
APPLICATION_ID_2]
get_application_details.return_value = _create_detail_response(self.APPLICATION_ID, self.OFFERER_ID,
self.VENUE_ID)
PROCEDURE_ID_VENUE_WITHOUT_SIRET = '5636727'
TOKEN = '4872'
offerer = create_offerer(siren='793875030', idx=self.OFFERER_ID)
venue = create_venue(offerer=offerer, idx=self.VENUE_ID)
PcObject.save(venue)
# when
with patch.dict(os.environ, {
'DEMARCHES_SIMPLIFIEES_VENUE_WITHOUT_SIRET_PROCEDURE_ID': PROCEDURE_ID_VENUE_WITHOUT_SIRET,
'DEMARCHES_SIMPLIFIEES_TOKEN': TOKEN
}, clear=True):
provider_test(app,
VenueWithoutSIRETBankInformationProvider,
None,
checkedObjects=0,
createdObjects=2,
updatedObjects=0,
erroredObjects=0,
checkedThumbs=0,
createdThumbs=0,
updatedThumbs=0,
erroredThumbs=0,
BankInformation=0)
# then
assert get_application_details.call_count == 2
assert get_application_details.call_args_list == [
call(self.APPLICATION_ID, PROCEDURE_ID_VENUE_WITHOUT_SIRET, TOKEN),
call(APPLICATION_ID_2, PROCEDURE_ID_VENUE_WITHOUT_SIRET, TOKEN)
]
def test_filter_query_where_user_is_user_offerer_and_is_validated(app):
# Given
user = create_user(email='*****@*****.**')
offerer1 = create_offerer(siren='123456789')
offerer2 = create_offerer(siren='987654321')
offerer3 = create_offerer(siren='123456780')
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
event1 = create_product_with_event_type(
event_name='Rencontre avec Jacques Martin')
event2 = create_product_with_event_type(
event_name='Concert de contrebasse')
thing1 = create_product_with_thing_type(thing_name='Jacques la fripouille')
thing2 = create_product_with_thing_type(thing_name='Belle du Seigneur')
venue1 = create_venue(offerer1,
name='Bataclan',
city='Paris',
siret=offerer1.siren + '12345')
venue2 = create_venue(offerer2,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer2.siren + '54321')
venue3 = create_venue(offerer3,
name='Une librairie du méchant concurrent gripsou',
city='Saint Denis',
siret=offerer3.siren + '54321')
offer1 = create_offer_with_event_product(venue1, event1)
offer2 = create_offer_with_event_product(venue1, event2)
offer3 = create_offer_with_thing_product(venue2, thing1)
offer4 = create_offer_with_thing_product(venue3, thing2)
PcObject.save(user_offerer1, user_offerer2, offerer3, offer1, offer2,
offer3, offer4)
# When
offers = filter_query_where_user_is_user_offerer_and_is_validated(
Offer.query.join(Venue).join(Offerer), user).all()
# Then
offer_ids = [offer.id for offer in offers]
assert offer1.id in offer_ids
assert offer2.id in offer_ids
assert offer3.id in offer_ids
assert offer4.id not in offer_ids
def test_create_filter_matching_all_keywords_in_any_models_with_several_keywords_at_just_venue_or_just_offerer_level(
app):
# given
event_product = create_product_with_event_type()
thing_product = create_product_with_thing_type()
ok_offerer1 = create_offerer(name="Librairie La Rencontre")
offerer2 = create_offerer(siren='123456788')
offerer3 = create_offerer(siren='123456787')
offerer4 = create_offerer(siren='123456786')
ok_venue1 = create_venue(ok_offerer1, siret=ok_offerer1.siren + '54321')
venue2 = create_venue(offerer2, siret=offerer2.siren + '12345')
ok_venue3 = create_venue(offerer3,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer3.siren + '54321')
venue4 = create_venue(offerer4,
name='Bataclan',
city='Paris',
siret=offerer4.siren + '12345')
ok_offer1 = create_offer_with_event_product(ok_venue1, event_product)
ko_offer2 = create_offer_with_event_product(venue2, event_product)
ok_offer3 = create_offer_with_thing_product(ok_venue1, thing_product)
ko_offer4 = create_offer_with_thing_product(venue2, thing_product)
ok_offer5 = create_offer_with_event_product(ok_venue3, event_product)
ko_offer6 = create_offer_with_event_product(venue4, event_product)
ok_offer7 = create_offer_with_thing_product(ok_venue3, thing_product)
ko_offer8 = create_offer_with_thing_product(venue4, thing_product)
PcObject.save(ok_offer1, ko_offer2, ok_offer3, ko_offer4, ok_offer5,
ko_offer6, ok_offer7, ko_offer8)
# when
query = filter_offers_with_keywords_string(build_offer_search_base_query(),
'Librairie Rencontre')
# then
found_offers = query.all()
found_offers_id = [found_offer.id for found_offer in found_offers]
assert ok_offer1.id in found_offers_id
assert ko_offer2.id not in found_offers_id
assert ok_offer3.id in found_offers_id
assert ko_offer4.id not in found_offers_id
assert ok_offer5.id in found_offers_id
assert ko_offer6.id not in found_offers_id
assert ok_offer7.id in found_offers_id
assert ko_offer8.id not in found_offers_id
def test_nOffers(app):
# given
offerer = create_offerer()
venue_1 = create_venue(offerer, siret='12345678912345')
venue_2 = create_venue(offerer, siret='67891234512345')
venue_3 = create_venue(offerer, siret='23451234567891')
offer_v1_1 = create_offer_with_thing_product(venue_1)
offer_v1_2 = create_offer_with_event_product(venue_1)
offer_v2_1 = create_offer_with_event_product(venue_2)
offer_v2_2 = create_offer_with_event_product(venue_2)
offer_v3_1 = create_offer_with_thing_product(venue_3)
PcObject.save(offer_v1_1, offer_v1_2, offer_v2_1, offer_v2_2, offer_v3_1)
# when
n_offers = offerer.nOffers
# then
assert n_offers == 5
def test_returns_one_when_user_with_one_cancelled_and_one_non_cancelled_bookings(self, app):
# Given
user_having_booked = create_user(departement_code='73')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue)
offer2 = create_offer_with_thing_product(venue)
stock1 = create_stock(offer=offer1, price=0)
stock2 = create_stock(offer=offer2, price=0)
booking1 = create_booking(user_having_booked, stock1, is_cancelled=False)
booking2 = create_booking(user_having_booked, stock2, is_cancelled=True)
PcObject.save(booking1, booking2)
# When
number_of_users_having_booked = count_users_having_booked_by_departement_code('73')
# Then
assert number_of_users_having_booked == 1
def test_count_users_by_departement_when_departement_code_given(self, app):
# Given
activated_user_from_74 = create_user(can_book_free_offers=True, departement_code='74')
activated_user_from_75 = create_user(can_book_free_offers=True, departement_code='75', email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue)
stock1 = create_stock(offer=offer1, price=0)
booking1 = create_booking(activated_user_from_74, stock1)
booking2 = create_booking(activated_user_from_75, stock1)
PcObject.save(booking1, booking2)
PcObject.save(activated_user_from_74, activated_user_from_75)
# When
count = count_users_having_booked('74')
# Then
assert count == 1
def when_the_token_is_missing(self, app):
# given
user = create_user(reset_password_token='KL89PBNG51')
PcObject.save(user)
data = {'newPassword': '******'}
# when
response = TestClient(app.test_client()).post(
'/users/new-password',
json=data,
headers={'origin': 'http://localhost:3000'})
# then
assert response.status_code == 400
assert response.json['token'] == [
'Votre lien de changement de mot de passe est invalide.'
]
def when_new_password_is_missing(self, app):
# given
user = create_user(reset_password_token='KL89PBNG51')
PcObject.save(user)
data = {'token': 'KL89PBNG51'}
# when
response = TestClient(app.test_client()).post(
'/users/new-password',
json=data,
headers={'origin': 'http://localhost:3000'})
# then
assert response.status_code == 400
assert response.json['newPassword'] == [
'Vous devez renseigner un nouveau mot de passe.'
]
def test_returns_an_event_if_it_is_given_in_department_list(self, app):
# given
product = create_product_with_event_type('Voir une pièce',
is_national=False)
offerer = create_offerer()
venue = create_venue(offerer,
is_virtual=False,
postal_code='29000',
departement_code='29')
offer = create_offer_with_event_product(venue, product)
PcObject.save(offer)
query = Product.query.filter_by(name='Voir une pièce')
# when
query = department_or_national_offers(query, ['29'])
# then
assert query.count() == 1
def when_offer_id_is_not_received(self, app):
# Given
user = create_user(email='*****@*****.**')
PcObject.save(user)
json = {
'mediationId': 'DA',
}
# When
response = TestClient(app.test_client()).with_auth(
user.email).post(f'{API_URL}/favorites', json=json)
# Then
assert response.status_code == 400
assert response.json['global'] == [
"Le paramètre offerId est obligatoire"
]
def test_does_not_show_anything_to_user_offerer_when_not_validated(
self, app):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
user_offerer = create_user_offerer(
user, offerer, validation_token=secrets.token_urlsafe(20))
offer = create_offer_with_thing_product(venue)
PcObject.save(user_offerer, offer)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# When
response = auth_request.get('/offers')
# Then
assert response.status_code == 200
assert response.json == []
def test_returns_national_event_with_different_department(self, app):
# given
product = create_product_with_event_type('Voir une pièce',
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer,
is_virtual=False,
postal_code='29000',
departement_code='29')
offer = create_offer_with_event_product(venue, product)
PcObject.save(offer)
query = Product.query.filter_by(name='Voir une pièce')
# when
query = department_or_national_offers(query, ['93'])
# then
assert product in query.all()
def do_ban_payments(message_id: str, payment_ids_to_ban: List[int]):
matching_payments = find_payments_by_message(message_id)
try:
banned_payments, retry_payments = apply_banishment(
matching_payments, payment_ids_to_ban)
except UnmatchedPayments as e:
logger.error('Le message "%s" ne contient pas les paiements : %s.'
'\nAucun paiement n\'a été mis à jour.' %
(message_id, e.payment_ids))
else:
if banned_payments:
PcObject.save(*(banned_payments + retry_payments))
logger.info('Paiements bannis : %s ' %
list(map(lambda p: p.id, banned_payments)))
logger.info('Paiements à réessayer : %s ' %
list(map(lambda p: p.id, retry_payments)))
def post_for_password_token():
validate_reset_request(request)
email = request.get_json()['email']
user = find_user_by_email(email)
if not user:
return '', 204
generate_reset_token(user)
PcObject.save(user)
app_origin_url = request.headers.get('origin')
try:
send_reset_password_email(user, send_raw_email, app_origin_url)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
return '', 204
def test_beginning_datetime_cannot_be_after_end_datetime(app):
# given
offer = create_offer_with_thing_product(create_venue(create_offerer()))
now = datetime.utcnow()
beginning = now - timedelta(days=5)
end = beginning - timedelta(days=1)
stock = create_stock(offer=offer,
beginning_datetime=beginning,
end_datetime=end)
# when
with pytest.raises(ApiErrors) as e:
PcObject.save(stock)
# then
assert e.value.errors['endDatetime'] == [
'La date de fin de l\'événement doit être postérieure à la date de début'
]
def when_user_has_already_seen_recommendation(self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer, postal_code='29100', siret='12345678912341')
offer = create_offer_with_thing_product(venue)
mediation = create_mediation(offer, is_active=True)
stock = create_stock_from_offer(offer)
recommendation = create_recommendation(offer=offer, user=user, mediation=mediation, is_clicked=False)
PcObject.save(stock, recommendation)
# when
response = TestClient(app.test_client()).with_auth(user.email) \
.put(RECOMMENDATION_URL, json={'seenRecommendationIds': [humanize(recommendation.id)]})
# then
assert response.status_code == 200
assert response.json == []
def when_offers_have_no_thumb_count_for_thing_and_a_mediation(
self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue, thumb_count=0)
stock = create_stock_from_offer(offer, price=0)
mediation = create_mediation(offer)
PcObject.save(user, stock, mediation)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL, json={'seenRecommendationIds': []})
# then
assert response.status_code == 200
assert len(response.json) == 1
def test_does_not_update_thing_when_unknonw_id_at_providers_in_given_zip_file(
self, app):
# given
filename = 'tests/local_providers/Resume-full_01012019.zip'
thing_1 = create_product_with_thing_type(
id_at_providers='1234567029006')
init_titelive_thing_descriptions = InitTiteLiveThingDescriptions(
filename)
init_titelive_thing_descriptions.dbObject.isActive = True
PcObject.save(thing_1, init_titelive_thing_descriptions.dbObject)
# when
init_titelive_thing_descriptions.updateObjects()
# then
assert init_titelive_thing_descriptions.checkedObjects == 0
assert init_titelive_thing_descriptions.updatedObjects == 0
def when_offerer_id_does_not_exist(self, app):
# given
user1 = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
offerer = create_offerer(siren='123456781')
user_offerer1 = create_user_offerer(user1, offerer)
user_offerer2 = create_user_offerer(user2, offerer)
PcObject.save(user_offerer1, user_offerer2)
non_existing_offerer_id = 'B9'
# when
response = TestClient(app.test_client()) \
.with_auth(email=user1.email) \
.get('/userOfferers/' + non_existing_offerer_id)
# then
assert response.status_code == 200
assert response.json == []
def test_send_transactions_set_status_to_error_with_details_if_email_was_not_sent_properly(
app):
# given
offerer1 = create_offerer(name='first offerer')
user = create_user()
venue1 = create_venue(offerer1)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock1)
booking3 = create_booking(user, stock1)
deposit = create_deposit(user, amount=500)
payments = [
create_payment(booking1,
offerer1,
Decimal(10),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking2,
offerer1,
Decimal(20),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking3,
offerer1,
Decimal(20),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555')
]
PcObject.save(deposit)
PcObject.save(*payments)
app.mailjet_client.send.create.return_value = Mock(status_code=400)
# when
send_transactions(payments, 'BD12AZERTY123456', 'AZERTY9Q666', '0000',
['*****@*****.**'])
# then
updated_payments = Payment.query.all()
for payment in updated_payments:
assert len(payment.statuses) == 2
assert payment.currentStatus.status == TransactionStatus.ERROR
assert payment.currentStatus.detail == "Erreur d'envoi à MailJet"
def test_send_transactions_creates_a_new_payment_transaction_if_email_was_sent_properly(
app):
# given@
offerer1 = create_offerer(name='first offerer')
user = create_user()
venue1 = create_venue(offerer1)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock1)
booking3 = create_booking(user, stock1)
deposit = create_deposit(user, amount=500)
payments = [
create_payment(booking1,
offerer1,
Decimal(10),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking2,
offerer1,
Decimal(20),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking3,
offerer1,
Decimal(20),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555')
]
PcObject.save(deposit)
PcObject.save(*payments)
app.mailjet_client.send.create.return_value = Mock(status_code=200)
# when
send_transactions(payments, 'BD12AZERTY123456', 'AZERTY9Q666', '0000',
['*****@*****.**'])
# then
updated_payments = Payment.query.all()
assert all(p.paymentMessageName == 'passCulture-SCT-20181015-092134'
for p in updated_payments)
assert all(p.paymentMessageChecksum == payments[0].paymentMessageChecksum
for p in updated_payments)
def validate():
token = request.args.get('token')
check_validation_request(token)
model_names = request.args.get('modelNames')
if model_names is None:
e = ApiErrors()
e.add_error('modelNames', 'Vous devez fournir des noms de classes')
return jsonify(e.errors), 400
model_names = model_names.split(',')
objects_to_validate = []
for model_name in model_names:
query = getattr(models, model_name) \
.query \
.filter_by(validationToken=token)
objects_to_validate += query.all()
if len(objects_to_validate) == 0:
return "Aucun(e) objet ne correspond à ce code de validation" \
+ " ou l'objet est déjà validé", \
404
for obj in objects_to_validate:
obj.validationToken = None
PcObject.save(*objects_to_validate)
user_offerers = iter(
[obj for obj in objects_to_validate if isinstance(obj, UserOfferer)])
user_offerer = next(user_offerers, None)
offerers = iter(
[obj for obj in objects_to_validate if isinstance(obj, Offerer)])
offerer = next(offerers, None)
try:
send_validation_confirmation_email(user_offerer, offerer,
send_raw_email)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
return "Validation effectuée", 202
