Page MenuHome

routes.py
No OneTemporary

File Metadata

Created
Tue, Nov 12, 12:49 AM

routes.py

import functools
import logging
from flask import Blueprint, render_template, redirect, url_for, request, jsonify, session
import flask_login
import werkzeug.exceptions as wz_exceptions
from pillar.auth import current_user as current_user
from pillar.api.utils import str2id
from pillar.web.utils import mass_attach_project_pictures
import pillar.web.subquery
from pillar.web.system_util import pillar_api
from pillar.web.projects.routes import project_view, project_navigation_links
import pillarsdk
from attract import current_attract
from attract.node_types.task import node_type_task
from attract.node_types.shot import node_type_shot
from attract.node_types.asset import node_type_asset
blueprint = Blueprint('attract', __name__)
log = logging.getLogger(__name__)
@blueprint.route('/')
def index():
api = pillar_api()
user = flask_login.current_user
if user.is_authenticated:
tasks = current_attract.task_manager.tasks_for_user(user.objectid)
else:
tasks = None
# TODO: add projections.
projects = current_attract.attract_projects()
if current_user.is_anonymous:
# Headers are only shown in index_anon_left_column.pug
mass_attach_project_pictures(projects['_items'], square=False, api=api)
projs_with_summaries = [
(proj, current_attract.shot_manager.shot_status_summary(proj['_id']))
for proj in projects['_items']
]
# Fetch all activities for all Attract projects.
id_to_proj = {p['_id']: p for p in projects['_items']}
activities = pillarsdk.Activity.all({
'where': {
'project': {'$in': list(id_to_proj.keys())},
},
'sort': [('_created', -1)],
'max_results': 20,
}, api=api)
# Fetch more info for each activity.
for act in activities['_items']:
act.actor_user = pillar.web.subquery.get_user_info(act.actor_user)
act.project = id_to_proj[act.project]
try:
act.link = current_attract.link_for_activity(act)
except (ValueError, wz_exceptions.NotFound):
act.link = None
project = session.get('attract_last_project')
return render_template('attract/index.html',
tasks=tasks,
projs_with_summaries=projs_with_summaries,
activities=activities,
project=project)
def error_project_not_setup_for_attract():
return render_template('attract/errors/project_not_setup.html')
def attract_project_view(extra_project_projections: dict=None, extension_props=False, *,
full_project=False):
"""Decorator, replaces the first parameter project_url with the actual project.
Assumes the first parameter to the decorated function is 'project_url'. It then
looks up that project, checks that it's set up for Attract, and passes it to the
decorated function.
If not set up for attract, uses error_project_not_setup_for_attract() to render
the response.
:param extra_project_projections: extra projections to use on top of the ones already
used by this decorator.
:param extension_props: whether extension properties should be included. Includes them
in the projections, and verifies that they are there.
:param full_project: skip projections altogether, fetching the whole project.
"""
if callable(extra_project_projections):
raise TypeError('Use with @attract_project_view() <-- note the parentheses')
projections = {
'_id': 1,
'name': 1,
'node_types': 1,
'nodes_featured': 1,
'extension_props': 1,
# We don't need this here, but this way the wrapped function has access
# to the orignal URL passed to it.
'url': 1,
}
if extra_project_projections:
projections.update(extra_project_projections)
def decorator(wrapped):
@functools.wraps(wrapped)
def wrapper(project_url, *args, **kwargs):
if isinstance(project_url, pillarsdk.Resource):
# This is already a resource, so this call probably is from one
# view to another. Assume the caller knows what he's doing and
# just pass everything along.
return wrapped(project_url, *args, **kwargs)
if current_user.is_anonymous:
log.debug('attract_project_view: Anonymous user never has access to Attract.')
raise wz_exceptions.Forbidden()
api = pillar_api()
projection_param = None if full_project else {'projection': projections}
project = pillarsdk.Project.find_by_url(
project_url,
projection_param,
api=api)
is_attract = current_attract.is_attract_project(project,
test_extension_props=extension_props)
if not is_attract:
return error_project_not_setup_for_attract()
session['attract_last_project'] = project.to_dict()
# Check user access.
auth = current_attract.auth
auth.determine_user_rights(str2id(project['_id']))
if not auth.current_user_may(auth.Actions.VIEW):
log.info('User %s not allowed to use Attract', current_user)
raise wz_exceptions.Forbidden()
if extension_props:
pprops = project.extension_props.attract
return wrapped(project, pprops, *args, **kwargs)
return wrapped(project, *args, **kwargs)
return wrapper
return decorator
@blueprint.route('/<project_url>')
@attract_project_view(extension_props=False)
def project_index(project):
return redirect(url_for('attract.shots.perproject.index', project_url=project.url))
@blueprint.route('/<project_url>/help')
@attract_project_view(extension_props=False)
def help(project):
nt_task = project.get_node_type(node_type_task['name'])
nt_shot = project.get_node_type(node_type_shot['name'])
statuses = set(nt_task['dyn_schema']['status']['allowed'] +
nt_shot['dyn_schema']['status']['allowed'])
return render_template('attract/help.html', statuses=statuses)
def project_settings(project: pillarsdk.Project, **template_args: dict):
"""Renders the project settings page for Attract projects."""
from . import EXTENSION_NAME
if not current_attract.auth.current_user_is_attract_user():
raise wz_exceptions.Forbidden()
# Based on the project state, we can render a different template.
if not current_attract.is_attract_project(project):
return render_template('attract/project_settings/offer_setup.html',
project=project, **template_args)
ntn_shot = node_type_shot['name']
ntn_asset = node_type_asset['name']
try:
attract_props = project['extension_props'][EXTENSION_NAME]
except KeyError:
# Not set up for attract, can happen.
shot_task_types = []
asset_task_types = []
else:
shot_task_types = attract_props['task_types'][ntn_shot]
asset_task_types = attract_props['task_types'][ntn_asset]
return render_template('attract/project_settings/settings.html',
project=project,
asset_node_type_name=ntn_asset,
shot_node_type_name=ntn_shot,
shot_task_types=shot_task_types,
asset_task_types=asset_task_types,
**template_args)
@blueprint.route('/<project_url>/<node_type_name>/set-task-types', methods=['POST'])
@attract_project_view(extension_props=True, full_project=True)
def save_task_types(project, attract_props, node_type_name: str):
from . import EXTENSION_NAME
from . import setup
import re
from collections import OrderedDict
valid_name_re = re.compile(r'^[0-9a-zA-Z &+\-.,_]+$')
if (not node_type_name.startswith('%s_' % EXTENSION_NAME)
or node_type_name not in attract_props['task_types']
or not valid_name_re.match(node_type_name)):
log.info('%s: received invalid node type name %r', request.endpoint, node_type_name)
raise wz_exceptions.BadRequest('Invalid node type name')
task_types_field = request.form.get('task_types')
if not task_types_field:
raise wz_exceptions.BadRequest('No task types given')
task_types = [
tt for tt in (tt.strip()
for tt in task_types_field.split('\n'))
if tt
]
task_types = list(OrderedDict.fromkeys(task_types)) # removes duplicates, maintains order.
if not all(valid_name_re.match(tt) for tt in task_types):
raise wz_exceptions.BadRequest('Invalid task type given')
setup.set_task_types(project.to_dict(), node_type_name, task_types)
return jsonify(task_types=task_types)
@blueprint.route('/<project_url>/setup-for-attract', methods=['POST'])
@flask_login.login_required
@project_view()
def setup_for_attract(project: pillarsdk.Project):
import attract.setup
project_id = project._id
if not project.has_method('PUT'):
log.warning('User %s tries to set up project %s for Attract, but has no PUT rights.',
current_user, project_id)
raise wz_exceptions.Forbidden()
log.info('User %s sets up project %s for Attract', current_user, project_id)
attract.setup.setup_for_attract(project.url)
return '', 204

Event Timeline