class PodcastDetailsSchema(Schema): id = fields.Int(required=True) name = fields.Str(required=True) description = fields.Str(required=True) created_at = fields.DateTime(required=True) image_url = fields.URL() rss_link = fields.URL() download_automatically = fields.Boolean(default=True) episodes_count = fields.Integer(default=0)
class EpisodeDetailsSchema(Schema): id = fields.Int(required=True) title = fields.Str(required=True) author = fields.Str() status = fields.Str() status_display = fields.Str() length = fields.Int(required=True) watch_url = fields.URL() remote_url = fields.URL() image_url = fields.URL() file_size = fields.Int() description = fields.Str() created_at = fields.DateTime(required=True) published_at = fields.DateTime(required=True, allow_none=True)
class RHConnectService(RHEditingManagementBase): """Set the service URL to be used for the event's editing workflow.""" @use_kwargs({ 'url': fields.URL(schemes={'http', 'https'}, required=True), }) def _process(self, url): if editing_settings.get(self.event, 'service_url'): raise BadRequest('Service URL already set') url = url.rstrip('/') info = check_service_url(url) if info['error'] is not None: abort(422, messages={'url': [info['error']]}) if not editing_settings.get(self.event, 'service_event_identifier'): editing_settings.set(self.event, 'service_event_identifier', make_event_identifier(self.event)) editing_settings.set_multi(self.event, { 'service_url': url, 'service_token': unicode(uuid4()), }) # we need to commit the token so the service can already use it when processing # the enabled event in case it wants to set up tags etc db.session.commit() try: service_handle_enabled(self.event) except ServiceRequestFailed as exc: editing_settings.delete(self.event, 'service_url', 'service_token') db.session.commit() raise ServiceUnavailable( _('Could not register event with service: {}').format(exc)) except Exception: editing_settings.delete(self.event, 'service_url', 'service_token') db.session.commit() raise return '', 204
def rel_me_auth(): if request.method == "GET": if "payload" not in session: return render_template("login.html") me = session["payload"]["me"] else: args = parser.parse({"me": fields.URL(required=True)}, request, location="form") me = args["me"] # find supported profiles and use the first one profiles = find_profiles(me) if not profiles: abort( 400, { "messages": [ f'Could not find a rel="me" link in {me} pointing to a valid profile ({", ".join(PROVIDERS)})' ] }, ) profile = list(profiles)[0] session["tentative_me"] = me session["profiles"] = profiles return redirect(url_for(f"{profile}.login"))
class EventSchema(Schema): title = fields.String(required=True) url = fields.URL(schemes={"http", "https"}, required=True) token = fields.String(required=True) config_endpoints = fields.Nested( EventEndpointsSchema, required=True, )
class RHCheckServiceURL(RHEditingManagementBase): """Check the service URL provided by a user.""" @use_kwargs({ 'url': fields.URL(schemes={'http', 'https'}, required=True), }) def _process(self, url): url = url.rstrip('/') return jsonify(check_service_url(url))
class EventInfoSchema(Schema): title = fields.String(required=True) url = fields.URL(schemes={'http', 'https'}, required=True) can_disconnect = fields.Boolean(required=True, default=True) service = fields.Nested( EventInfoServiceSchema, required=True, default=SERVICE_INFO, )
class EventInfoSchema(Schema): title = fields.String(required=True) url = fields.URL(schemes={"http", "https"}, required=True) can_disconnect = fields.Boolean(required=True, default=True) service = fields.Nested( { "version": fields.String(), "name": fields.String() }, required=True, default=SERVICE_INFO, )
class RetreatProposalModelSchema(Schema): id = fields.Int(dump_only=True) retreat_id = fields.Int(dump_only=True) created_at = fields.AwareDateTime(dump_only=True) image_url = fields.URL(required=True) title = fields.String(required=True) body = fields.String() flight_time_avg = fields.Float(required=True) lodging_cost = fields.Integer(required=True) flights_cost = fields.Integer(required=True) other_cost = fields.Integer(required=True) extra_info = fields.String()
from flask import Blueprint, render_template, current_app, make_response from webargs import fields, flaskparser from .image import PLACEHOLDER OPTIONS = { 'font': fields.Str(missing='titilliumweb-black'), 'image': fields.URL(missing=PLACEHOLDER), } blueprint = Blueprint('custom-page', __name__) @blueprint.route("/custom") @flaskparser.use_kwargs(OPTIONS) def get(font, image): html = render_template( 'custom.html', fonts=sorted(current_app.font_service.all()), font=font, image=image, config=current_app.config, ) response = make_response(html) response.headers['Cache-Control'] = f'max-age={60*60*24*7}' return response
return redirect(url_for("get_auth", **payload)) return redirect(url_for("index")) @app.route("/logout", methods=["GET"]) def logout(): session.pop("me", None) return redirect(url_for("index")) @app.route("/auth", methods=["GET"]) @use_kwargs( { "response_type": fields.Str(required=True), "me": fields.URL(required=True), "client_id": fields.URL(required=True), "redirect_uri": fields.URL(required=True), "state": fields.Str(required=True), "scope": fields.DelimitedList(fields.Str(), delimiter=" ", missing=[]), }, location="query", ) def get_auth( response_type: str, me: str, client_id: str, redirect_uri: str, state: str, scope: List[str], ):
class ProgressEpisodeSchema(Schema): id = fields.Int() title = fields.Str() image_url = fields.URL() status = fields.Str()
class ProgressPodcastSchema(Schema): id = fields.Int() name = fields.Str() image_url = fields.URL()
class EpisodeListSchema(Schema): id = fields.Int(required=True) title = fields.Str(required=True) created_at = fields.DateTime(required=True) image_url = fields.URL() status = fields.Str(required=True)
class EpisodeCreateSchema(Schema): source_url = fields.URL(required=True)
from flask import Flask, render_template, jsonify from webargs import flaskparser, fields import requests from .utils import filter_invalid_urls app = Flask(__name__) @app.route('/') def index(): return render_template('index.html') @app.route('/proxy') @flaskparser.use_kwargs({'url': fields.URL()}) def proxy(url): try: response = requests.get(url) except IOError: return "" else: return response.text @app.route('/validate', methods=['POST']) @flaskparser.use_kwargs({'urls': fields.List(fields.Str(), missing=[])}) def validate(urls): data = [] for url in filter_invalid_urls(urls):
class EventSchema(Schema): title = fields.String(required=True) url = fields.URL(schemes={'http', 'https'}, required=True) token = fields.String(required=True) endpoints = fields.Nested(EventEndpointsSchema, required=True)
class RHLocations(RHRoomBookingAdminBase): def _process_args(self): id_ = request.view_args.get('location_id') self.location = Location.get_one( id_, is_deleted=False) if id_ is not None else None def _jsonify_one(self, location): return jsonify(admin_locations_schema.dump(location, many=False)) def _jsonify_many(self): query = Location.query.filter_by(is_deleted=False) return jsonify(admin_locations_schema.dump(query.all())) def _process_GET(self): if self.location: return self._jsonify_one(self.location) else: return self._jsonify_many() def _process_DELETE(self): # XXX: we could safely allow deleting any locations regardless of whether there # are rooms now that we soft-delete them. but it's probably safer to disallow # deletion of locations with rooms, simply to prevent accidental deletions. if self.location.rooms: raise ExpectedError(_('Cannot delete location with active rooms')) self.location.is_deleted = True logger.info('Location %r deleted by %r', self.location, session.user) # this code currently doesn't do anything since we don't allow deleting locations # that have non-deleted rooms, but if we change this in the future it's needed for room in self.location.rooms: logger.info('Deleting room %r', room) room.is_deleted = True db.session.flush() return '', 204 @use_kwargs({ 'name': fields.String(required=True), 'room_name_format': fields.String(validate=[ lambda value: all(x in value for x in ('{building}', '{floor}', '{number}')) ], required=True), 'map_url_template': fields.URL(schemes={'http', 'https'}, allow_none=True, missing=''), }) def _process_POST(self, name, room_name_format, map_url_template): self._check_conflict(name) loc = Location(name=name, room_name_format=room_name_format, map_url_template=(map_url_template or '')) db.session.add(loc) db.session.flush() return self._jsonify_one(loc), 201 @use_kwargs({ 'name': fields.String(), 'room_name_format': fields.String(validate=[ lambda value: all(x in value for x in ('{building}', '{floor}', '{number}')) ]), 'map_url_template': fields.URL(schemes={'http', 'https'}, allow_none=True), }) def _process_PATCH(self, name=None, room_name_format=None, map_url_template=missing): if name is not None: self._check_conflict(name) self.location.name = name if room_name_format is not None: self.location.room_name_format = room_name_format if map_url_template is not missing: self.location.map_url_template = map_url_template or '' db.session.flush() return self._jsonify_one(self.location) def _check_conflict(self, name): query = Location.query.filter( ~Location.is_deleted, db.func.lower(Location.name) == name.lower()) if self.location: query = query.filter(Location.id != self.location.id) if query.has_rows(): abort(422, messages={'name': [_('Name must be unique')]})
class PlayListRequestSchema(Schema): url = fields.URL()
class PlayListEntitySchema(Schema): id = fields.Str() title = fields.Str() description = fields.Str() thumbnail_url = fields.URL() url = fields.URL()
def send_reset_link_args(): """Defines and validates params for sending a password reset link""" return { "email_or_username": fields.String(required=True), "base_url": fields.URL(required=True) }