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 })