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