def wrapper(self, req, resp, *args, **kwargs):
validated_params = None
validated_payload = None
if params_schema:
validated_params, errors = params_schema().load(req.params)
if errors:
if error_schema is not None:
errors, n = error_schema().dump(errors)
raise HTTPError(HTTP_422, description=errors)
if payload_schema:
validated_payload, errors = payload_schema().load(req.media)
if errors:
if error_schema is not None:
errors, n = error_schema().dump(errors)
raise HTTPError(HTTP_422, description=errors)
return func(self,
req,
resp,
*args,
validated_params=validated_params,
validated_payload=validated_payload,
description=description,
summary=summary,
response_schema=response_schema,
error_schema=error_schema,
success_response_code=success_response_code,
**kwargs)
def on_post(req, resp, team, roster):
"""
Add user to a roster for a team
"""
team, roster = unquote(team), unquote(roster)
data = load_json_body(req)
user_name = data.get('name')
in_rotation = int(data.get('in_rotation', True))
if not user_name:
raise HTTPBadRequest('incomplete data', 'missing field "name"')
check_team_auth(team, req)
connection = db.connect()
cursor = connection.cursor()
cursor.execute(
'''(SELECT `id` FROM `team` WHERE `name`=%s)
UNION
(SELECT `id` FROM `user` WHERE `name`=%s)''',
(team, user_name))
results = [r[0] for r in cursor]
if len(results) < 2:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'invalid team or user')
# TODO: validate roster
(team_id, user_id) = results
try:
# also make sure user is in the team
cursor.execute(
'''INSERT IGNORE INTO `team_user` (`team_id`, `user_id`) VALUES (%r, %r)''',
(team_id, user_id))
cursor.execute(
'''INSERT INTO `roster_user` (`user_id`, `roster_id`, `in_rotation`)
VALUES (
%r,
(SELECT `roster`.`id` FROM `roster`
JOIN `team` ON `team`.`id`=`roster`.`team_id`
WHERE `team`.`name`=%s AND `roster`.`name`=%s),
%s
)''', (user_id, team, roster, in_rotation))
# subscribe user to notifications
subscribe_notifications(team, user_name, cursor)
create_audit(
{
'roster': roster,
'user': user_name,
'request_body': data
}, team, ROSTER_USER_ADDED, req, cursor)
connection.commit()
except db.IntegrityError:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'user "%(name)s" is already in the roster' % data)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
resp.body = json_dumps(get_user_data(None, {'name': user_name})[0])
def __handle__(*args, **kwargs):
service = kwargs.get('service_name', 'Service')
try:
r = function(*args, **kwargs)
if r.status_code == 404:
raise HTTPNotFound()
if r.status_code == 500:
raise HTTPInternalServerError(
'Failed to process request on {}'.format(service),
code='102')
if r.status_code > 299:
raise HTTPError(str(r.status_code))
return r
except requests.exceptions.Timeout:
logger.error('{} Inventory Timeout'.format(service))
raise HTTPError(
HTTP_REQUEST_TIMEOUT,
title='{} Timeout'.format(service),
description='{} connection timeout'.format(service),
code='100')
except requests.exceptions.ConnectionError:
raise HTTPError(HTTP_INTERNAL_SERVER_ERROR,
title='{} Connection Error'.format(service),
description='{} connection error'.format(service),
code='101')
def __init__(self, code=0):
global Error_text
self.code = code
if self.code not in Error_text.keys():
self.code = 0
self.text = Error_text[self.code][0]
self.http_code = Error_text[self.code][1]
HTTPError.__init__(self, self.http_code, self.text, code=self.code)
def __init__(self, code=0):
global Error_text
self.code = code
if self.code not in Error_text.keys():
self.code = 0
self.text = Error_text[self.code][0]
self.http_code = Error_text[self.code][1]
HTTPError.__init__(self, self.http_code, self.text, code=self.code)
def score_message(hug_token, message_id: hug.types.number,
score: hug.types.number):
try:
msg = Message.get(Message.token == Token.get(Token.token == hug_token),
Message.id == message_id, Message.reply_to != None)
Score.create(message=msg, value=score)
return {"status": "ok"}
except Message.DoesNotExist:
raise HTTPError(HTTP_404)
except peewee.IntegrityError:
raise HTTPError(HTTP_409)
def registration(login: hug.types.text, password: hug.types.text):
if len(password) >= 6:
password = hashlib.sha1(password.encode()).hexdigest()
else:
raise HTTPError(HTTP_422)
token = uuid.uuid4().hex
token = Token.create(token=token)
try:
User.create(**locals())
except peewee.IntegrityError:
token.delete()
raise HTTPError(HTTP_409)
return {'status': 'ok'}
def __handle__(*args, **kwargs):
"""
:param args:
:param kwargs:
service_name: the name of the service that is using the requester
:return: the response object if no error detected
:raises:
requests.exceptions.Timeout: when the timeout is reached
requests.exceptions.ConnectionError: When no connection is available
"""
service = kwargs.get('service_name', 'Service')
if 'ignore_exception' in kwargs:
r = function(*args, **kwargs)
return r
try:
r = function(*args, **kwargs)
if r.status_code == 401:
raise HTTPUnauthorized(
title='You are not authorized',
description='Please validate your authentication')
if r.status_code == 404:
raise HTTPNotFound()
if r.status_code == 500:
logger.error('Internal server error, message {}'.format(
r.text))
raise HTTPInternalServerError(
'Failed to process request on {}'.format(service),
code='102')
if r.status_code > 299:
logger.error('Failed to process request, message {}'.format(
r.text))
raise HTTPError(str(r.status_code),
description=r.text,
code='103')
return r
except requests.exceptions.Timeout:
logger.error('{} Timeout'.format(service))
raise HTTPError(
HTTP_REQUEST_TIMEOUT,
title='{} Timeout'.format(service),
description='{} connection timeout'.format(service),
code='100')
except requests.exceptions.ConnectionError:
raise HTTPError(HTTP_INTERNAL_SERVER_ERROR,
title='{} Connection Error'.format(service),
description='{} connection error'.format(service),
code='101')
def on_post(req, resp, team):
"""
Add user as team admin
"""
team = unquote(team)
check_team_auth(team, req)
data = load_json_body(req)
user_name = data.get('name')
if not user_name:
raise HTTPBadRequest('name attribute missing from request')
connection = db.connect()
cursor = connection.cursor()
cursor.execute('''(SELECT `id` FROM `team` WHERE `name`=%s)
UNION
(SELECT `id` FROM `user` WHERE `name`=%s)''', (team, user_name))
results = [r[0] for r in cursor]
if len(results) < 2:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', 'invalid team or user')
(team_id, user_id) = results
try:
# also make sure user is in the team
cursor.execute('''INSERT IGNORE INTO `team_user` (`team_id`, `user_id`) VALUES (%r, %r)''',
(team_id, user_id))
cursor.execute('''INSERT INTO `team_admin` (`team_id`, `user_id`) VALUES (%r, %r)''',
(team_id, user_id))
# subscribe user to team notifications
subscribe_notifications(team, user_name, cursor)
create_audit({'user': user_name}, team, ADMIN_CREATED, req, cursor)
connection.commit()
except db.IntegrityError as e:
err_msg = str(e.args[1])
if err_msg == "Column 'team_id' cannot be null":
err_msg = 'team %s not found' % team
if err_msg == "Column 'user_id' cannot be null":
err_msg = 'user %s not found' % data['name']
else:
err_msg = 'user name "%s" is already an admin of team %s' % (data['name'], team)
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
resp.body = json_dumps(get_user_data(None, {'name': user_name})[0])
def on_post(req, resp, team):
data = load_json_body(req)
check_team_auth(team, req)
sub_name = data.get('subscription')
role_name = data.get('role')
if not sub_name or not role_name:
raise HTTPBadRequest('Invalid subscription',
'Missing subscription name or role name')
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute(
'''INSERT INTO `team_subscription` (`team_id`, `subscription_id`, `role_id`) VALUES
((SELECT `id` FROM `team` WHERE `name` = %s),
(SELECT `id` FROM `team` WHERE `name` = %s),
(SELECT `id` FROM `role` WHERE `name` = %s))''',
(team, sub_name, role_name))
except db.IntegrityError as e:
err_msg = str(e.args[1])
if err_msg == 'Column \'team_id\' cannot be null':
err_msg = 'team "%s" not found' % team
elif err_msg == 'Column \'role_id\' cannot be null':
err_msg = 'role "%s" not found' % role_name
elif err_msg == 'Column \'subscription_id\' cannot be null':
err_msg = 'team "%s" not found' % sub_name
logger.exception('Unknown integrity error in team_subscriptions')
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
else:
connection.commit()
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
def main(self, run):
try:
if callable(run):
run()
else:
raise Exception('run argument must be executable')
# HttpError is different from HTTPError
# HttpError is error from googleapiclient
# HTTPError belongs to falcon
except HttpError as err:
status_code = err.resp.status
if status_code == 404:
from falcon import HTTP_404
falcon_status = HTTP_404
elif status_code == 403:
from falcon import HTTP_403
falcon_status = HTTP_403
else:
from falcon import HTTP_400
falcon_status = HTTP_400
raise HTTPError(falcon_status,
description=err._get_reason() or '',
code=status_code)
except Exception as err:
print('Exception in getting spreadsheet info', err)
raise HTTPInternalServerError(
description='Something went wrong while getting sheets info')
def __call__(self, ex, req, resp, params):
# type: (Exception, Request, response, dict) -> None
logger.warning('Exception occurred on request %s %s',
req.method,
req.uri,
exc_info=ex)
raise HTTPError(self._status, self._title, str(ex))
def on_put(req, resp, team):
team = unquote(team)
check_team_auth(team, req)
data = load_json_body(req)
connection = db.connect()
cursor = connection.cursor()
data_cols = data.keys()
if 'name' in data:
invalid_char = invalid_char_reg.search(data['name'])
if invalid_char:
raise HTTPBadRequest('invalid team name',
'team name contains invalid character "%s"' % invalid_char.group())
set_clause = ', '.join(['`{0}`=%s'.format(d) for d in data_cols if d in cols])
query_params = tuple(data[d] for d in data_cols) + (team,)
try:
update_query = 'UPDATE `team` SET {0} WHERE name=%s'.format(set_clause)
cursor.execute(update_query, query_params)
create_audit({'request_body': data}, team, TEAM_EDITED, req, cursor)
connection.commit()
except db.IntegrityError as e:
err_msg = str(e.args[1])
if 'Duplicate entry' in err_msg:
err_msg = "A team named '%s' already exists" % (data['name'])
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
def raise_error(self,
error_code=None,
desc='Something went wrong in server'):
if error_code and error_code != 500:
if error_code == 401 or error_code == 403:
redis_cli = Redis.get_redis_client()
if redis_cli is not None:
access_token = redis_cli.delete('sheets_v4_access')
else:
print('Redis client is not active')
if error_code == 400:
raise HTTPBadRequest(description=desc or '')
elif error_code == 401:
raise HTTPUnauthorized(description=desc or '')
elif error_code == 403:
raise HTTPForbidden(description=desc or '')
elif error_code == 404:
raise HTTPNotFound(description=desc or '')
elif error_code == 409:
raise HTTPConflict(description=desc or '')
elif error_code == 412:
raise HTTPPreconditionFailed(description=desc or '')
elif error_code == 422:
raise HTTPUnprocessableEntity(description=desc or '')
elif error_code == 503:
raise HTTPServiceUnavailable(description=desc or '')
else:
raise HTTPError(HTTP_400,
description=desc or '',
code=error_code)
else:
raise HTTPInternalServerError(description=desc or '')
def get_token(login: hug.types.text, password: hug.types.text):
try:
user = User.get(login=login,
password=hashlib.sha1(password.encode()).hexdigest())
return {'token': user.token.token}
except User.DoesNotExist:
raise HTTPError(HTTP_404)
def on_post(req, resp, team):
"""
Create team to service mapping
"""
team = unquote(team)
check_team_auth(team, req)
data = load_json_body(req)
service = data['name']
connection = db.connect()
cursor = connection.cursor()
try:
# TODO: allow many to many mapping for team/service?
cursor.execute(
'''SELECT `team`.`name` from `team_service`
JOIN `team` ON `team`.`id` = `team_service`.`team_id`
JOIN `service` ON `service`.`id` = `team_service`.`service_id`
WHERE `service`.`name` = %s''', service)
claimed_team = [r[0] for r in cursor]
if claimed_team:
raise HTTPError(
'422 Unprocessable Entity', 'IntegrityError',
'service "%s" alread claimed by team "%s"' %
(service, claimed_team[0]))
cursor.execute(
'''INSERT INTO `team_service` (`team_id`, `service_id`)
VALUES (
(SELECT `id` FROM `team` WHERE `name`=%s),
(SELECT `id` FROM `service` WHERE `name`=%s)
)''', (team, service))
connection.commit()
except db.IntegrityError as e:
err_msg = str(e.args[1])
if err_msg == 'Column \'service_id\' cannot be null':
err_msg = 'service "%s" not found' % service
elif err_msg == 'Column \'team_id\' cannot be null':
err_msg = 'team "%s" not found' % team
elif 'Duplicate entry' in err_msg:
err_msg = 'service name "%s" is already associated with team %s' % (
service, team)
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
def on_post(req, resp):
if 'user' not in req.context:
# ban API auth because we don't know who to set as team admin
raise HTTPBadRequest('invalid login',
'API key auth is not allowed for team creation')
data = load_json_body(req)
if not data.get('name'):
raise HTTPBadRequest('', 'name attribute missing from request')
if not data.get('scheduling_timezone'):
raise HTTPBadRequest(
'', 'scheduling_timezone attribute missing from request')
team_name = unquote(data['name'])
invalid_char = invalid_char_reg.search(team_name)
if invalid_char:
raise HTTPBadRequest(
'invalid team name',
'team name contains invalid character "%s"' % invalid_char.group())
scheduling_timezone = unquote(data['scheduling_timezone'])
slack = data.get('slack_channel')
if slack and slack[0] != '#':
raise HTTPBadRequest('invalid slack channel',
'slack channel name needs to start with #')
email = data.get('email')
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute(
'''
INSERT INTO `team` (`name`, `slack_channel`, `email`, `scheduling_timezone`)
VALUES (%s, %s, %s, %s)''',
(team_name, slack, email, scheduling_timezone))
team_id = cursor.lastrowid
query = '''
INSERT INTO `team_user` (`team_id`, `user_id`)
VALUES (%s, (SELECT `id` FROM `user` WHERE `name` = %s))'''
cursor.execute(query, (team_id, req.context['user']))
query = '''
INSERT INTO `team_admin` (`team_id`, `user_id`)
VALUES (%s, (SELECT `id` FROM `user` WHERE `name` = %s))'''
cursor.execute(query, (team_id, req.context['user']))
subscribe_notifications(team_name, req.context['user'], cursor)
create_audit({'team_id': team_id}, data['name'], TEAM_CREATED, req,
cursor)
connection.commit()
except db.IntegrityError:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'team name "%s" already exists' % team_name)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
def on_put(req, resp, team, roster):
"""
Change roster name. Must have team admin privileges.
**Example request:**
.. sourcecode:: http
PUT /api/v0/teams/team-foo/rosters/roster-foo HTTP/1.1
Content-Type: application/json
{
"name": "roster-bar",
}
:statuscode 400: Invalid roster name, disallowed characters
:statuscode 422: Duplicate roster name for team
"""
team, roster = unquote(team), unquote(roster)
data = load_json_body(req)
name = data.get('name')
check_team_auth(team, req)
if not name:
raise HTTPBadRequest('invalid team name', 'team name is missing')
if name == roster:
return
invalid_char = invalid_char_reg.search(name)
if invalid_char:
raise HTTPBadRequest(
'invalid team name',
'team name contains invalid character "%s"' % invalid_char.group())
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute(
'''UPDATE `roster` SET `name`=%s
WHERE `team_id`=(SELECT `id` FROM `team` WHERE `name`=%s)
AND `name`=%s''', (name, team, roster))
create_audit({
'old_name': roster,
'new_name': name
}, team, ROSTER_EDITED, req, cursor)
connection.commit()
except db.IntegrityError as e:
err_msg = str(e.args[1])
if 'Duplicate entry' in err_msg:
err_msg = "roster '%s' already existed for team '%s'" % (name,
team)
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
def parse_item(req):
"""
Do some validation on the request and decode the json
:param req: a falcon request object
:return: item dictionary
"""
if not req.content_length:
raise HTTPError(status="400 no content found")
try:
item = json.load(req.stream)
except ValueError:
raise HTTPError(status="400 invalid JSON")
if 'cart_id' in item and not is_valid_cart_id(item.get('cart_id')):
raise HTTPError(status="400 invalid cart_id")
if 'cart_id' in req.cookies and not is_valid_cart_id(
req.cookies.get('cart_id')):
raise HTTPError(status="400 invalid cart_id")
if 'external_id' not in item:
raise HTTPError(status="400 external_id is required")
return item
def start_new(filename, settings, overwrite):
overwrite = str_to_bool(overwrite)
if not overwrite and HoodTracker.saveFileExists(filename):
raise HTTPError(
falcon.HTTP_409,
title="File Exists",
description=f'A save file named {filename} already exists')
global save_filename, settings_string
save_filename = filename
settings_string = settings
return step(new_game=True)
def http_error_factory(status: str = HTTP_799,
title: str = __default_human_title,
description: str = __default_description,
headers: Union[Dict[str, str], List[Tuple[str,
str]]] = None,
href: str = None,
href_text: str = None,
code: int = None) -> HTTPError:
""" Returns a raise-able HTTPError based on the input parameters
:param status: HTTP status code and text, such as '400 Bad Request'
:type status: str
:param title: Human-friendly error title. If not provided, defaults to the HTTP status line as determined by the
:code`status` parameter
:type title: str
:param description: Human-friendly description of the error, along with a helpful suggestion or two (default `None`)
:type description: str
:param headers: A dict of header names and values to set, or a list of (*name*, *value*) tuples. Both *name* and
*value* must be of type str or StringType, and only character values 0x00 through 0xFF may be used on platforms
that use wide characters
Note:
The Content-Type header, if present, will be overridden. If
you wish to return custom error messages, you can create
your own HTTP error class, and install an error handler
to convert it into an appropriate HTTP response for the
client
Note:
Falcon can process a list of tuple slightly faster
than a dict
:type headers: Union[Dict[str, str], List[Tuple[str, str]]]
:param href: A URL someone can visit to find out more information (default None). Unicode characters are
percent-encoded
:type href: str
:param href_text: If href is given, use this as the friendly title/description for the link (default 'API
documentation for this error')
:type href_text: str
:param code: An internal code that customers can reference in their support request or to help them when searching
for knowledge base articles related to this error (default ``None``)
:type code: int
:return: Falcon HTTP Error
:rtype: HTTPError
"""
logger.error(msg='{status}: {title}\n\t\t{description}'.format(
status=status, title=title, description=description))
return HTTPError(status=status,
title=title,
description=description,
headers=headers,
href=href,
href_text=href_text,
code=code)
def on_post(req, resp, team):
"""
Add user to a team
"""
check_team_auth(team, req)
data = load_json_body(req)
user_name = data.get('name')
if not user_name:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'name missing for user')
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute(
'''INSERT INTO `team_user` (`team_id`, `user_id`)
VALUES (
(SELECT `id` FROM `team` WHERE `name`=%s),
(SELECT `id` FROM `user` WHERE `name`=%s)
)''', (team, user_name))
connection.commit()
except db.IntegrityError as e:
err_msg = str(e.args[1])
if err_msg == 'Column \'user_id\' cannot be null':
err_msg = 'user %s not found' % user_name
elif err_msg == 'Column \'team_id\' cannot be null':
err_msg = 'team %s not found' % team
elif 'Duplicate entry' in err_msg:
err_msg = 'user name "%s" is already in team %s' % (user_name,
team)
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
resp.body = json_dumps(get_user_data(None, {'name': user_name})[0])
def on_post(req, resp, user_name):
'''
Pin a team to the landing page for a user
**Example request**:
.. sourcecode:: http
POST /api/v0/users/jdoe/pinned_teams HTTP/1.1
Host: example.com
{
"team": "team-foo"
}
:statuscode 201: Successful team pin
:statuscode 400: Missing team parameter or team already pinned
'''
check_user_auth(user_name, req)
data = load_json_body(req)
team = data.get('team')
if team is None:
raise HTTPBadRequest('Invalid team pin', 'Missing team parameter')
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute('''INSERT INTO `pinned_team` (`user_id`, `team_id`)
VALUES ((SELECT `id` FROM `user` WHERE `name` = %s),
(SELECT `id` FROM `team` WHERE `name` = %s))''',
(user_name, team))
connection.commit()
except db.IntegrityError as e:
# Duplicate key
if e.args[0] == 1062:
raise HTTPBadRequest('Invalid team pin', 'Team already pinned for this user')
# Team/user is null
elif e.args[0] == 1048:
err_msg = str(e.args[1])
if err_msg == 'Column \'user_id\' cannot be null':
err_msg = 'user "%s" not found' % user_name
elif err_msg == 'Column \'team_id\' cannot be null':
err_msg = 'team "%s" not found' % team
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
def on_post(req, resp):
data = load_json_body(req)
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute('INSERT INTO `service` (`name`) VALUES (%(name)s)',
data)
connection.commit()
except db.IntegrityError:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'service name "%(name)s" already exists' % data)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
def on_post(req, resp):
"""
Create user. Currently used only in debug mode.
"""
data = load_json_body(req)
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute('INSERT INTO `user` (`name`) VALUES (%(name)s)', data)
connection.commit()
except db.IntegrityError:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'user name "%(name)s" already exists' % data)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
def on_post(req, resp):
data = load_json_body(req)
new_role = data['name']
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute('INSERT INTO `role` (`name`) VALUES (%s)', new_role)
connection.commit()
except db.IntegrityError as e:
err_msg = str(e.args[1])
if 'Duplicate entry' in err_msg:
err_msg = 'role "%s" already existed' % new_role
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
resp.status = HTTP_201
def __handle__(*args, **kwargs):
try:
r = function(*args, **kwargs)
return r
except ServerSelectionTimeoutError:
logger.error('DB Timeout')
raise HTTPError(HTTP_REQUEST_TIMEOUT,
title='DB Timeout',
description='DB connection timeout',
code='100')
except Exception as e:
logger.exception('DB error')
error = dict(title='Database Error')
try:
error['description'] = e.orig.msg
except Exception:
error['description'] = e.args[0]
error['code'] = '105'
raise HTTPInternalServerError(**error)
def on_get(req, resp, team):
"""
Get roster info(including schedules) for a team
"""
team = unquote(team)
connection = db.connect()
cursor = connection.cursor(db.DictCursor)
cursor.execute('SELECT `id` FROM `team` WHERE `name`=%s', team)
if cursor.rowcount != 1:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'team "%s" not found' % team)
team_id = cursor.fetchone()['id']
rosters = get_roster_by_team_id(cursor, team_id, req.params)
cursor.close()
connection.close()
resp.body = json_dumps(rosters)
def on_post(req, resp, team):
"""
Create a roster for a team
"""
team = unquote(team)
data = load_json_body(req)
roster_name = data.get('name')
if not roster_name:
raise HTTPBadRequest('name attribute missing from request', '')
invalid_char = invalid_char_reg.search(roster_name)
if invalid_char:
raise HTTPBadRequest(
'invalid roster name',
'roster name contains invalid character "%s"' %
invalid_char.group())
check_team_auth(team, req)
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute(
'''INSERT INTO `roster` (`name`, `team_id`)
VALUES (%s, (SELECT `id` FROM `team` WHERE `name`=%s))''',
(roster_name, team))
except db.IntegrityError:
raise HTTPError(
'422 Unprocessable Entity', 'IntegrityError',
'roster name "%s" already exists for team %s' %
(roster_name, team))
create_audit({
'roster_id': cursor.lastrowid,
'request_body': data
}, team, ROSTER_CREATED, req, cursor)
connection.commit()
cursor.close()
connection.close()
resp.status = HTTP_201
def on_put(req, resp, team, roster):
"""
Change roster name
"""
team, roster = unquote(team), unquote(roster)
data = load_json_body(req)
check_team_auth(team, req)
if data['name'] == roster:
return
invalid_char = invalid_char_reg.search(data['name'])
if invalid_char:
raise HTTPBadRequest(
'invalid team name',
'team name contains invalid character "%s"' % invalid_char.group())
connection = db.connect()
cursor = connection.cursor()
try:
cursor.execute(
'''UPDATE `roster` SET `name`=%s
WHERE `team_id`=(SELECT `id` FROM `team` WHERE `name`=%s)
AND `name`=%s''', (data['name'], team, roster))
create_audit({
'old_name': roster,
'new_name': data['name']
}, team, ROSTER_EDITED, req, cursor)
connection.commit()
except db.IntegrityError as e:
err_msg = str(e.args[1])
if 'Duplicate entry' in err_msg:
err_msg = "roster '%s' already existed for team '%s'" % (
data['name'], team)
raise HTTPError('422 Unprocessable Entity', 'IntegrityError', err_msg)
finally:
cursor.close()
connection.close()
def on_get(req, resp, team):
"""
Get roster info for a team. Returns a JSON object with roster names
as keys, and info as values. This info includes the roster id, any
schedules associated with the rosters, and roster users (along
with their status as in/out of rotation).
**Example request**:
.. sourcecode:: http
GET /api/v0/teams/team-foo/rosters HTTP/1.1
Host: example.com
**Example response**:
.. sourcecode:: http
HTTP/1.1 200 OK
Content-Type: application/json
{
"roster-foo": {
"id": 2923,
"schedules": [
{
"advanced_mode": 0,
"auto_populate_threshold": 30,
"events": [
{
"duration": 604800,
"start": 266400
}
],
"id": 1788,
"role": "primary",
"role_id": 1,
"roster": "roster-foo",
"roster_id": 2923,
"team": "team-foo",
"team_id": 2122,
"timezone": "US/Pacific"
}
],
"users": [
{
"in_rotation": true,
"name": "jdoe"
},
{
"in_rotation": true,
"name": "asmith"
}
]
}
}
:statuscode 422: Invalid team
"""
team = unquote(team)
connection = db.connect()
cursor = connection.cursor(db.DictCursor)
cursor.execute('SELECT `id` FROM `team` WHERE `name`=%s', team)
if cursor.rowcount != 1:
raise HTTPError('422 Unprocessable Entity', 'IntegrityError',
'team "%s" not found' % team)
team_id = cursor.fetchone()['id']
rosters = get_roster_by_team_id(cursor, team_id, req.params)
cursor.close()
connection.close()
resp.body = json_dumps(rosters)
