def add_to_favorite():
mediation = None
offer_id = request.json.get('offerId')
mediation_id = request.json.get('mediationId')
check_offer_id_is_present_in_request(offer_id)
offer = load_or_404(Offer, offer_id)
if mediation_id != None:
mediation = load_or_404(Mediation, mediation_id)
favorite = create_favorite(mediation, offer, current_user)
PcObject.save(favorite)
return jsonify(_serialize_favorite(favorite)), 201
def edit_venue(venueId):
venue = load_or_404(Venue, venueId)
ensure_current_user_has_rights(app.model.RightsType.editor,
venue.managingOffererId)
update(venue, request.json)
app.model.PcObject.check_and_save(venue)
return jsonify(venue._asdict(include=VENUES_INCLUDES)), 200
def deactivate_venue_offers(venueId):
venue = load_or_404(Venue, venueId)
ensure_current_user_has_rights(RightsType.editor, venue.managingOffererId)
offers = venue.offers
deactivated_offers = update_is_active_status(offers, False)
PcObject.save(*deactivated_offers)
return jsonify([as_dict(offer, includes=OFFER_INCLUDES) for offer in deactivated_offers]), 200
def delete_event_occurence(id):
eo = load_or_404(EventOccurence, id)
ensure_current_user_has_rights(app.model.RightsType.editor,
eo.venue.managingOffererId)
#TODO: S'il y a des réservations il faut envoyer des mails !
#TODO: Interdire la suppression d'évenements passés
return delete(eo, request.json)
def create_event_occurence():
print('request.json', request.json)
eo = EventOccurence(from_dict=request.json)
venue = load_or_404(Venue, request.json['venueId'])
ensure_current_user_has_rights(app.model.RightsType.editor,
venue.managingOffererId)
app.model.PcObject.check_and_save(eo)
return jsonify(eo._asdict()), 201
def patch_thing(id):
thing = load_or_404(Thing, id)
update(thing, request.json)
app.model.PcObject.check_and_save(thing)
return jsonify(
thing._asdict(include=THING_INCLUDES,
has_dehumanized_id=True,
has_model_name=True)), 200
def edit_venue(venueId):
venue = load_or_404(Venue, venueId)
check_valid_edition(request, venue)
validate_coordinates(request.json.get('latitude', None), request.json.get('longitude', None))
ensure_current_user_has_rights(RightsType.editor, venue.managingOffererId)
venue.populate_from_dict(request.json)
save_venue(venue)
return jsonify(as_dict(venue, includes=VENUE_INCLUDES)), 200
def edit_event_occurence(id):
eo = load_or_404(EventOccurence, id)
ensure_current_user_has_rights(app.model.RightsType.editor,
eo.venue.managingOffererId)
update(eo, request.json)
#TODO: Si changement d'horaires et qu'il y a des réservations il faut envoyer des mails !
#TODO: Interdire la modification d'évenements passés
app.model.PcObject.check_and_save(eo)
return jsonify(eo._asdict(include=VENUES_INCLUDES)), 200
def patch_event(id):
event = load_or_404(Event, id)
update(event, request.json)
app.model.PcObject.check_and_save(event)
return jsonify(
event._asdict(
include=EVENT_INCLUDES,
has_dehumanized_id=True,
has_model_name=True
)
), 200
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 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 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 create_venue_provider():
new_vp = VenueProvider(from_dict=request.json)
# CHECK THAT THIS PROVIDER IS ACTIVE
provider = load_or_404(Provider, request.json['providerId'])
if not provider.isActive:
errors = app.model.ApiErrors()
errors.status_code = 401
errors.addError('localClass', "Ce fournisseur n' est pas activé")
errors.maybeRaise()
return
# CHECK THAT THERE IS NOT ALREADY A VENUE PROVIDER
# FOR THE SAME VENUE, PROVIDER, IDENTIFIER
same_venue_provider = VenueProvider.query.filter_by(
providerId=provider.id,
venueId=dehumanize(request.json['venueId']),
venueIdAtOfferProvider=request.json['venueIdAtOfferProvider']
).first()
if same_venue_provider:
errors = app.model.ApiErrors()
errors.status_code = 401
errors.addError('venueIdAtOfferProvider', "Il y a déjà un fournisseur pour votre identifiant")
errors.maybeRaise()
# SAVE
app.model.PcObject.check_and_save(new_vp)
# CALL THE PROVIDER SUB PROCESS
api_root = Path(path.dirname(path.realpath(__file__))) / '..'
p = subprocess.Popen('PYTHONPATH="." python scripts/pc.py update_providables'
+ ' --venueProvider ' + str(new_vp.id),
#stdout=subprocess.PIPE,
#stderr=subprocess.PIPE,
shell=True,
cwd=api_root)
#out, err = p.communicate()
#print("STDOUT:", out)
#print("STDERR:", err)
# RETURN
return jsonify(new_vp._asdict(include=VENUE_PROVIDER_INCLUDES)), 201
def get_event(id):
event = load_or_404(Event, id)
print('event.type', event.type)
return jsonify(
event._asdict(include=EVENT_INCLUDES)
), 200
def edit_venue_provider(id):
vp = load_or_404(VenueProvider, id)
update(vp, request.json)
app.model.PcObject.check_and_save(vp)
return jsonify(vp._asdict()), 200
def get_venue_provider(id):
vp = load_or_404(VenueProvider, id)
return jsonify(vp._asdict(include=VENUE_PROVIDER_INCLUDES))
def get_venue_provider(id):
venue_provider = load_or_404(VenueProvider, id)
return jsonify(as_dict(venue_provider, includes=VENUE_PROVIDER_INCLUDES))
def get_offerer(id):
ensure_current_user_has_rights(RightsType.editor, dehumanize(id))
offerer = load_or_404(Offerer, id)
return jsonify(get_dict_offerer(offerer)), 200
def get_mediation(id):
mediation = load_or_404(Mediation, id)
return jsonify(mediation._asdict())
def get_score(id):
score = load_or_404(Score, id)
return jsonify(score.asdict(includes=SCORE_INCLUDES)), 200
def get_event_occurence(venueId):
eo = load_or_404(EventOccurence, id)
return jsonify(eo._asdict())
def delete_mediation(id):
mediation = load_or_404(Mediation, id)
ensure_current_user_has_rights(RightsType.editor, mediation.offererId)
return delete(mediation)
def patch_staff_voice(id):
staff_voice = load_or_404(StaffVoice, id)
staff_voice.populateFromDict(request.json)
Wrapper.check_and_save(staff_voice)
return jsonify(staff_voice.asdict(includes=STAFF_VOICE_INCLUDES)), 200
def get_venue(venueId):
venue = load_or_404(Venue, venueId)
return jsonify(venue._asdict(include=VENUES_INCLUDES))
def get_favorite(favorite_id):
favorite = load_or_404(Favorite, favorite_id)
return jsonify(_serialize_favorite(favorite)), 200
def get_mediation(mediation_id):
mediation = load_or_404(Mediation, mediation_id)
return jsonify(as_dict(mediation))
def delete_venue_provider(id):
vp = load_or_404(VenueProvider, id)
ensure_current_user_has_rights(app.model.RightsType.editor,
vp.venue.managingOffererId)
# TODO: should we also delete all the associated events/things...?
return delete(vp)
def get_offer(id):
offer = load_or_404(Offer, id)
return jsonify(as_dict(offer, includes=OFFER_INCLUDES))
def get_venue(venueId):
venue = load_or_404(Venue, venueId)
ensure_current_user_has_rights(RightsType.editor, venue.managingOffererId)
return jsonify(as_dict(venue, includes=VENUE_INCLUDES)), 200
