def get_pending_validation():
check_user_is_admin(current_user)
result = []
offerers = offerer_queries.find_all_pending_validation()
for offerer in offerers:
result.append(
as_dict(offerer, includes=OFFERER_FOR_PENDING_VALIDATION_INCLUDES))
return jsonify(result), 200
def delete_favorite(offer_id):
dehumanized_offer_id = dehumanize(offer_id)
favorite = find_favorite_for_offer_and_user(dehumanized_offer_id,
current_user.id) \
.first_or_404()
PcObject.delete(favorite)
return jsonify(as_dict(favorite)), 200
def test_returns_humanized_ids_for_foreign_keys(self, app):
# given
user = create_user(postal_code=None, idx=12)
booking = create_booking(user, Stock(), idx=13)
booking.userId = user.id
# when
dict_result = as_dict(booking, includes=[])
# then
assert dict_result['userId'] == 'BQ'
def update_mediation(mediation_id):
mediation = load_or_404(Mediation, mediation_id)
ensure_current_user_has_rights(RightsType.editor,
mediation.offer.venue.managingOffererId)
mediation = Mediation.query.filter_by(id=dehumanize(mediation_id)).first()
data = request.json
mediation.populate_from_dict(data)
invalidate_recommendations_if_deactivating_object(
data, mediation.recommendations)
PcObject.save(mediation)
return jsonify(as_dict(mediation, includes=MEDIATION_INCLUDES)), 200
def create_booking():
stock_id = request.json.get('stockId')
recommendation_id = request.json.get('recommendationId')
quantity = request.json.get('quantity')
stock = Stock.query.filter_by(id=dehumanize(stock_id)).first()
try:
check_has_stock_id(stock_id)
check_existing_stock(stock)
user_bookings = find_all_bookings_for_stock_and_user(
stock, current_user)
check_already_booked(user_bookings)
check_has_quantity(quantity)
check_booking_quantity_limit(quantity)
check_offer_date(stock)
check_not_soft_deleted_stock(stock)
check_can_book_free_offer(stock, current_user)
check_offer_is_active(stock)
check_stock_booking_limit_date(stock)
check_stock_venue_is_validated(stock)
except ApiErrors as api_errors:
return jsonify(api_errors.errors), 400
new_booking = Booking(
from_dict={
'stockId': stock_id,
'amount': stock.price,
'token': random_token(),
'userId': humanize(current_user.id),
'quantity': quantity,
'recommendationId':
recommendation_id if recommendation_id else None
})
bookings = find_active_bookings_by_user_id(current_user.id)
expenses = get_expenses(bookings)
check_expenses_limits(expenses, new_booking)
PcObject.save(new_booking)
try:
send_booking_recap_emails(new_booking, send_raw_email)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
try:
send_booking_confirmation_email_to_user(new_booking, send_raw_email)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
return jsonify(
as_dict(new_booking, includes=WEBAPP_PATCH_POST_BOOKING_INCLUDES)), 201
def edit_stock(stock_id):
stock_data = request.json
query = Stock.queryNotSoftDeleted().filter_by(id=dehumanize(stock_id))
stock = query.first_or_404()
check_offer_is_editable(stock.offer)
check_dates_are_allowed_on_existing_stock(stock_data, stock.offer)
offerer_id = stock.resolvedOffer.venue.managingOffererId
ensure_current_user_has_rights(RightsType.editor, offerer_id)
stock.populate_from_dict(stock_data)
PcObject.save(stock)
return jsonify(as_dict(stock)), 200
def create_mediation():
check_thumb_in_request(files=request.files, form=request.form)
offerer_id = dehumanize(request.form['offererId'])
offer_id = dehumanize(request.form['offerId'])
credit = request.form.get('credit')
ensure_current_user_has_rights(RightsType.editor, offerer_id)
mediation = create_new_mediation(offer_id, offerer_id, current_user,
credit)
thumb = read_thumb(files=request.files, form=request.form)
check_thumb_quality(thumb)
PcObject.save(mediation)
save_thumb(mediation, thumb, 0, crop=_get_crop(request.form))
return jsonify(as_dict(mediation)), 201
def test_returns_included_properties(self, app):
# given
user = create_user(postal_code=None)
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user_offerer)
USER_INCLUDES = ['hasPhysicalVenues', 'hasOffers']
# when
dict_result = as_dict(user, includes=USER_INCLUDES)
# then
assert 'hasPhysicalVenues' in dict_result
assert 'hasOffers' in dict_result
def test_does_not_return_excluded_keys(self, app):
# given
user = create_user(postal_code=None)
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user_offerer)
USER_INCLUDES = ['-password', '-resetPasswordToken']
# when
dict_result = as_dict(user, includes=USER_INCLUDES)
# then
assert 'password' not in dict_result
assert 'resetPasswordToken' not in dict_result
def create_venue_provider():
venue_provider_payload = request.json
validate_new_venue_provider_information(venue_provider_payload)
new_venue_provider = VenueProvider(from_dict=venue_provider_payload)
PcObject.save(new_venue_provider)
subprocess.Popen('PYTHONPATH="." python scripts/pc.py update_providables' +
' --venue-provider-id %s' % str(new_venue_provider.id),
shell=True,
cwd=API_ROOT_PATH)
return jsonify(
as_dict(new_venue_provider, includes=VENUE_PROVIDER_INCLUDES)), 201
def create_stock():
request_data = request.json
check_request_has_offer_id(request_data)
offer_id = dehumanize(request_data.get('offerId', None))
offer = find_offer_by_id(offer_id)
check_offer_is_editable(offer)
check_dates_are_allowed_on_new_stock(request_data, offer)
offerer = offerer_queries.get_by_offer_id(offer_id)
ensure_current_user_has_rights(RightsType.editor, offerer.id)
new_stock = Stock(from_dict=request_data)
PcObject.save(new_stock)
return jsonify(as_dict(new_stock)), 201
def list_venue_providers():
venue_id = request.args.get('venueId')
if venue_id is None:
e = ApiErrors()
e.add_error('venueId',
'Vous devez obligatoirement fournir le paramètre venueId')
return jsonify(e.errors), 400
vp_query = VenueProvider.query \
.filter_by(venueId=dehumanize(venue_id))
return jsonify([
as_dict(venue_provider, includes=VENUE_PROVIDER_INCLUDES)
for venue_provider in vp_query.all()
])
def get_offer_helper(offer):
return dict(as_dict(offer), **{
"keywordsString": '{} {}'.format(
offer.product.name,
offer.venue.name
).replace('?', ' ')
.replace('!', ' ') \
.replace('(', '') \
.replace(')', '') \
.replace('ù', 'u'),
"venueCity": offer.venue.city,
"venueName": offer.venue.name,
"thingName": offer.product.name
})
def get_stock(stock_id, mediation_id):
filters = request.args.copy()
query = find_stocks_with_possible_filters(
filters, current_user).filter_by(id=dehumanize(stock_id))
if mediation_id is not None:
mediation = load_or_404(Mediation, mediation_id)
if stock_id == '0':
stock = {'id': '0', 'thing': {'id': '0', 'mediations': [mediation]}}
return jsonify(stock)
else:
stock = query.first_or_404()
return jsonify(as_dict(stock))
def export_table(model_name):
_check_token()
ae = ApiErrors()
if model_name not in models.__all__:
ae.add_error('global', 'Classe inconnue : ' + model_name)
return jsonify(ae.errors), 400
try:
model = getattr(models, model_name)
except KeyError:
ae.add_error('global', 'Nom de classe incorrect : ' + model_name)
return jsonify(ae.errors), 400
if not _is_exportable(model_name):
ae.add_error('global', 'Classe non exportable : ' + model_name)
return jsonify(ae.errors), 400
objects = model.query.all()
if len(objects) == 0:
return "", 200
csvfile = StringIO()
header = _clean_dict_for_export(model_name, as_dict(objects[0])).keys()
if model_name == 'User':
header = list(filter(lambda h: h != 'id' and h != 'password', header))
writer = csv.DictWriter(csvfile, header, extrasaction='ignore')
writer.writeheader()
for obj in objects:
dct = _clean_dict_for_export(model_name, as_dict(obj))
writer.writerow(dct)
csvfile.seek(0)
mem = BytesIO()
mem.write(csvfile.getvalue().encode('utf-8'))
mem.seek(0)
csvfile.close()
return send_file(mem, attachment_filename='export.csv', as_attachment=True)
def test_returns_included_properties_on_joined_relationships(self, app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
event_product = create_product_with_event_type(event_name='My Event')
offer = create_offer_with_event_product(venue, product=event_product)
mediation = create_mediation(offer)
PcObject.save(mediation)
EVENT_INCLUDES = [{"key": "mediations", "includes": ["thumbUrl"]}]
# when
dict_result = as_dict(offer, includes=EVENT_INCLUDES)
# then
assert 'thumbUrl' in dict_result['mediations'][0]
def list_providers():
providers = get_enabled_providers_for_pro()
result = []
for provider in providers:
p_dict = as_dict(provider)
if provider.localClass is not None and hasattr(local_providers,
provider.localClass):
provider_class = getattr(local_providers, provider.localClass)
p_dict['identifierRegexp'] = provider_class.identifierRegexp
p_dict[
'identifierDescription'] = provider_class.identifierDescription
del p_dict['apiKey']
del p_dict['apiKeyGenerationDate']
result.append(p_dict)
return jsonify(result)
def test_returns_model_keys(self, app):
# given
user = create_user(postal_code=None)
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user_offerer)
USER_INCLUDES = []
# when
dict_result = as_dict(user, includes=USER_INCLUDES)
# then
assert 'publicName' in dict_result
assert 'lastName' in dict_result
assert 'firstName' in dict_result
def test_returns_model_keys_on_joined_relationships(self, app):
# given
user = create_user()
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user_offerer)
USER_INCLUDES = ['offerers']
# when
dict_result = as_dict(user, includes=USER_INCLUDES)
# then
assert 'offerers' in dict_result
assert 'name' in dict_result['offerers'][0]
assert 'siren' in dict_result['offerers'][0]
def post_storage_file(collectionName, id, index):
model_name = inflect_engine.singular_noun(collectionName.title(), 1)
if model_name not in GENERIC_STORAGE_MODEL_NAMES:
return jsonify({'text': 'upload is not authorized for this model'}), 400
model = getattr(models, model_name)
entity = model.query.filter_by(id=dehumanize(id)).first_or_404()
if model_name == 'Mediation':
offerer_id = entity.offer.venue.managingOffererId
ensure_current_user_has_rights(RightsType.editor, offerer_id)
save_thumb(entity, request.files['file'].read(), int(index))
return jsonify(as_dict(entity)), 200
def handle_rest_get_list(modelClass,
query=None,
refine=None,
order_by=None,
flask_request=None,
includes=(),
print_elements=None,
paginate=None,
page=None,
populate=None):
if flask_request is None:
flask_request = request
if query is None:
query = modelClass.query
# DELETED
if issubclass(modelClass, SoftDeletableMixin):
query = query.filter_by(isSoftDeleted=False)
# REFINE
if refine:
query = refine(query)
# ORDER BY
if order_by:
check_order_by(order_by)
query = query_with_order_by(query, order_by)
# PAGINATE
if paginate:
if page is not None:
page = int(page)
query = query.paginate(page, per_page=paginate, error_out=False) \
.items
objects = [o for o in query]
if populate:
objects = list(map(populate, objects))
# DICTIFY
elements = [as_dict(o, includes=includes) for o in query]
# PRINT
if print_elements:
print(elements)
# RETURN
return jsonify(elements), 200
def create_venue():
validate_coordinates(request.json.get('latitude', None), request.json.get('longitude', None))
venue = Venue(from_dict=request.json)
venue.departementCode = 'XX' # avoid triggerring check on this
siret = request.json.get('siret')
if not siret:
venue.generate_validation_token()
save_venue(venue)
if not venue.isValidated:
try:
send_venue_validation_email(venue, send_raw_email)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
return jsonify(as_dict(venue, includes=VENUE_INCLUDES)), 201
def patch_offer(id):
thing_or_event_dict = request.json
check_valid_edition(request.json)
offer = offer_queries.find_offer_by_id(dehumanize(id))
if not offer:
raise ResourceNotFound
ensure_current_user_has_rights(RightsType.editor,
offer.venue.managingOffererId)
check_offer_is_editable(offer)
offer.populate_from_dict(request.json)
offer.update_with_product_data(thing_or_event_dict)
PcObject.save(offer)
if 'isActive' in request.json and not request.json['isActive']:
invalidate_recommendations(offer)
return jsonify(as_dict(offer, includes=OFFER_INCLUDES)), 200
def test_offer_as_dict_returns_dateRange_in_ISO_8601(self):
# Given
offer = Offer()
offer.stocks = [
create_stock(offer=offer,
beginning_datetime=datetime(2018, 10, 22, 10, 10, 10),
end_datetime=datetime(2018, 10, 22, 13, 10, 10))
]
# When
offer_dict = as_dict(offer, includes=["dateRange"])
# Then
assert offer_dict['dateRange'] == [
'2018-10-22T10:10:10Z', '2018-10-22T13:10:10Z'
]
def delete_stock(id):
stock = load_or_404(Stock, id)
check_offer_is_editable(stock.offer)
offerer_id = stock.resolvedOffer.venue.managingOffererId
ensure_current_user_has_rights(RightsType.editor, offerer_id)
bookings = delete_stock_and_cancel_bookings(stock)
if bookings:
try:
send_batch_cancellation_emails_to_users(bookings, send_raw_email)
send_batch_cancellation_email_to_offerer(bookings, 'stock',
send_raw_email)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
PcObject.save(stock, *bookings)
return jsonify(as_dict(stock)), 200
def post_offer():
venue_id = request.json.get('venueId')
check_has_venue_id(venue_id)
venue = load_or_raise_error(Venue, venue_id)
ensure_current_user_has_rights(RightsType.editor, venue.managingOffererId)
product_id = dehumanize(request.json.get('productId'))
if product_id:
offer = initialize_offer_from_product_id(product_id)
else:
offer_type_name = request.json.get('type')
check_offer_type_is_valid(offer_type_name)
offer = fill_offer_with_new_data(request.json, current_user)
offer.product.owningOfferer = venue.managingOfferer
offer.venue = venue
offer.bookingEmail = request.json.get('bookingEmail', None)
PcObject.save(offer)
send_offer_creation_notification_to_administration(offer, current_user,
PRO_URL, send_raw_email)
return jsonify(as_dict(offer, includes=OFFER_INCLUDES)), 201
def signup_pro():
objects_to_save = []
app_origin_url = request.headers.get('origin')
check_valid_signup_pro(request)
new_user = User(from_dict=request.json)
existing_offerer = Offerer.query.filter_by(
siren=request.json['siren']).first()
if existing_offerer:
user_offerer = _generate_user_offerer_when_existing_offerer(
new_user, existing_offerer)
offerer = existing_offerer
else:
offerer = _generate_offerer(request.json)
user_offerer = offerer.give_rights(new_user, RightsType.editor)
digital_venue = create_digital_venue(offerer)
objects_to_save.extend([digital_venue, offerer])
objects_to_save.append(user_offerer)
new_user.canBookFreeOffers = False
new_user.isAdmin = False
new_user.needsToFillCulturalSurvey = False
new_user = _set_offerer_departement_code(new_user, offerer)
new_user.generate_validation_token()
objects_to_save.append(new_user)
PcObject.save(*objects_to_save)
try:
send_user_validation_email(new_user,
send_raw_email,
app_origin_url,
is_webapp=False)
subscribe_newsletter(new_user)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
return jsonify(as_dict(new_user, includes=USER_INCLUDES)), 201
def get_recommendation_helper(recommendation):
return as_dict(recommendation, includes=RECOMMENDATION_INCLUDES)
def get_venue_helper(venue):
return as_dict(venue)
def get_booking_helper(booking):
return dict(
as_dict(booking), **{
"eventOrThingName": booking.recommendation.offer.product.name,
"venueName": booking.recommendation.offer.venue.name
})
