def post(self):
"""
Uploads an image using the image upload service
---
tags:
- system
produces:
- application/json
parameters:
- in: header
name: Authorization
description: Base64 encoded session token
required: true
type: string
default: Token sessionTokenHere==
- in: body
name: body
required: true
description: JSON object containing image data that will be uploaded
schema:
properties:
data:
type: string
default: base64 encoded image data
mime:
type: string
default: file mime/type
filename:
type: string
default: filename
responses:
200:
description: Image uploaded successfully
400:
description: Input parameter error
403:
description: User is not authorized to upload images
500:
description: A problem occurred
"""
if (
current_app.config["IMAGE_UPLOAD_API_URL"] is None
or current_app.config["IMAGE_UPLOAD_API_KEY"] is None
):
return {"Error": "Image upload service not defined"}, 500
try:
is_org_manager = (
len(
OrganisationService.get_organisations_managed_by_user(
tm.authenticated_user_id
)
)
> 0
)
data = request.get_json()
if is_org_manager:
if data.get("filename") is None:
return {"Error": "Missing filename parameter"}, 400
if data.get("mime") in ["image/png", "image/jpeg", "image/webp"]:
headers = {
"x-api-key": current_app.config["IMAGE_UPLOAD_API_KEY"],
"Content-Type": "application/json",
}
url = "{}?filename={}".format(
current_app.config["IMAGE_UPLOAD_API_URL"], data.get("filename")
)
result = requests.post(
url, headers=headers, data=json.dumps({"image": data})
)
if result.ok:
return result.json(), 201
else:
return result.json(), 400
else:
return (
{
"Error": "Mimetype is not allowed. Use are 'image/png', 'image/jpeg', 'image/webp'"
},
400,
)
else:
return {"Error": "User is not admin or organisation manager"}, 403
except Exception as e:
error_msg = f"Image upload POST API - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": "Unable to upload image"}, 500
def _filter_projects(search_dto: ProjectSearchDTO, user):
""" Filters all projects based on criteria provided by user"""
query = ProjectSearchService.create_search_query(user)
query = query.join(ProjectInfo).filter(
ProjectInfo.locale.in_([search_dto.preferred_locale, "en"]))
project_status_array = []
if search_dto.project_statuses:
for project_status in search_dto.project_statuses:
project_status_array.append(
ProjectStatus[project_status].value)
query = query.filter(Project.status.in_(project_status_array))
else:
if not search_dto.created_by:
project_status_array = [ProjectStatus.PUBLISHED.value]
query = query.filter(Project.status.in_(project_status_array))
if search_dto.interests:
query = query.join(
project_interests,
project_interests.c.project_id == Project.id).filter(
project_interests.c.interest_id.in_(search_dto.interests))
if search_dto.created_by:
query = query.filter(Project.author_id == search_dto.created_by)
if search_dto.mapped_by:
projects_mapped = UserService.get_projects_mapped(
search_dto.mapped_by)
query = query.filter(Project.id.in_(projects_mapped))
if search_dto.favorited_by:
user = UserService.get_user_by_id(search_dto.favorited_by)
projects_favorited = user.favorites
query = query.filter(
Project.id.in_([project.id for project in projects_favorited]))
if search_dto.mapper_level and search_dto.mapper_level.upper(
) != "ALL":
query = query.filter(Project.mapper_level == MappingLevel[
search_dto.mapper_level].value)
if search_dto.organisation_name:
query = query.filter(
Organisation.name == search_dto.organisation_name)
if search_dto.organisation_id:
query = query.filter(Organisation.id == search_dto.organisation_id)
if search_dto.team_id:
query = query.join(ProjectTeams,
ProjectTeams.project_id == Project.id).filter(
ProjectTeams.team_id == search_dto.team_id)
if search_dto.campaign:
query = query.join(Campaign, Project.campaign).group_by(
Project.id, Campaign.name)
query = query.filter(Campaign.name == search_dto.campaign)
if search_dto.mapping_types:
# Construct array of mapping types for query
mapping_type_array = []
for mapping_type in search_dto.mapping_types:
mapping_type_array.append(MappingTypes[mapping_type].value)
query = query.filter(
Project.mapping_types.contains(mapping_type_array))
if search_dto.text_search:
# We construct an OR search, so any projects that contain or more of the search terms should be returned
or_search = " | ".join(
[x for x in search_dto.text_search.split(" ") if x != ""])
opts = [
ProjectInfo.text_searchable.match(
or_search, postgresql_regconfig="english"),
ProjectInfo.name.like(f"%{or_search}%"),
]
try:
opts.append(Project.id == int(search_dto.text_search))
except ValueError:
pass
query = query.filter(or_(*opts))
if search_dto.country:
# Unnest country column array.
sq = Project.query.with_entities(
Project.id,
func.unnest(Project.country).label("country")).subquery()
query = query.filter(
sq.c.country.ilike("%{}%".format(
search_dto.country))).filter(Project.id == sq.c.id)
order_by = search_dto.order_by
if search_dto.order_by_type == "DESC":
order_by = desc(search_dto.order_by)
query = query.order_by(order_by).group_by(Project.id)
if search_dto.managed_by and user.role != UserRole.ADMIN.value:
team_projects = query.join(ProjectTeams).filter(
ProjectTeams.role == TeamRoles.PROJECT_MANAGER.value,
ProjectTeams.project_id == Project.id,
)
user_orgs_list = OrganisationService.get_organisations_managed_by_user(
search_dto.managed_by)
orgs_managed = [org.id for org in user_orgs_list]
org_projects = query.filter(
Project.organisation_id.in_(orgs_managed))
query = org_projects.union(team_projects)
all_results = []
if not search_dto.omit_map_results:
all_results = query.all()
paginated_results = query.paginate(search_dto.page, 14, True)
return all_results, paginated_results
