def patch(self, team_id):
"""
Updates a team
---
tags:
- teams
produces:
- application/json
parameters:
- in: header
name: Authorization
description: Base64 encoded session token
required: true
type: string
default: Token sessionTokenHere==
- name: team_id
in: path
description: The unique team ID
required: true
type: integer
default: 1
- in: body
name: body
required: true
description: JSON object for updating a team
schema:
properties:
name:
type: string
default: HOT - Mappers
logo:
type: string
default: https://tasks.hotosm.org/assets/img/hot-tm-logo.svg
members:
type: array
items:
schema:
$ref: "#/definitions/TeamMembers"
organisation:
type: string
default: HOT
description:
type: string
default: HOT's mapping editors
inviteOnly:
type: boolean
default: false
responses:
201:
description: Team updated successfully
400:
description: Client Error - Invalid Request
401:
description: Unauthorized - Invalid credentials
500:
description: Internal Server Error
"""
try:
team = TeamService.get_team_by_id(team_id)
team_dto = UpdateTeamDTO(request.get_json())
team_dto.team_id = team_id
team_dto.validate()
authenticated_user_id = token_auth.current_user()
if not TeamService.is_user_team_manager(
team_id, authenticated_user_id
) and not OrganisationService.can_user_manage_organisation(
team.organisation_id, authenticated_user_id):
return {
"Error": "User is not a admin or a manager for the team"
}, 401
except DataError as e:
current_app.logger.error(f"error validating request: {str(e)}")
return str(e), 400
try:
TeamService.update_team(team_dto)
return {"Status": "Updated"}, 200
except NotFound as e:
return {"Error": str(e)}, 404
except TeamServiceError as e:
return str(e), 402
except Exception as e:
error_msg = f"Team PATCH - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": error_msg}, 500
def post(self, team_id):
"""
Message all team members
---
tags:
- teams
produces:
- application/json
parameters:
- in: header
name: Authorization
description: Base64 encoded session token
required: true
type: string
default: Token sessionTokenHere==
- name: team_id
in: path
description: Unique team ID
required: true
type: integer
default: 1
- in: body
name: body
required: true
description: JSON object for creating message
schema:
properties:
subject:
type: string
default: Thanks
required: true
message:
type: string
default: Thanks for your contribution
required: true
responses:
200:
description: Message sent successfully
401:
description: Unauthorized - Invalid credentials
403:
description: Forbidden
500:
description: Internal Server Error
"""
try:
authenticated_user_id = token_auth.current_user()
team_id = request.view_args["team_id"]
message_dto = MessageDTO(request.get_json())
# Validate if team is present
try:
team = TeamService.get_team_by_id(team_id)
except NotFound:
return {"Error": "Team not found"}, 404
is_manager = TeamService.is_user_team_manager(
team_id, authenticated_user_id)
if not is_manager:
raise ValueError
message_dto.from_user_id = authenticated_user_id
message_dto.validate()
if not message_dto.message.strip(
) or not message_dto.subject.strip():
raise DataError({"Validation": "Empty message not allowed"})
except DataError as e:
current_app.logger.error(f"Error validating request: {str(e)}")
return {"Error": "Request payload did not match validation"}, 400
except ValueError:
return {
"Error": "Unauthorised to send message to team members"
}, 403
try:
threading.Thread(
target=TeamService.send_message_to_all_team_members,
args=(team_id, team.name, message_dto),
).start()
return {"Success": "Message sent successfully"}, 200
except ValueError as e:
return {"Error": str(e)}, 403
except Exception as e:
error_msg = f"Send message all - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": "Unable to send messages to team members"}, 500