def get_organisations(manager_user_id: int):
if manager_user_id is None:
""" Get all organisations """
return Organisation.get_all_organisations()
else:
return Organisation.get_organisations_managed_by_user(
manager_user_id)
def get_organisation_by_name(organisation_name: str) -> Organisation:
organisation = Organisation.get_organisation_by_name(organisation_name)
if organisation is None:
raise NotFound()
return organisation
def get_organisation_by_id(organisation_id: int) -> Organisation:
org = Organisation.get(organisation_id)
if org is None:
raise NotFound()
return org
def get_organisation_by_id_as_dto(organisation_id: int, user_id: int):
org = Organisation.get(organisation_id)
if org is None:
raise NotFound()
organisation_dto = org.as_dto()
organisation_dto.projects = []
organisation_dto.teams = []
if user_id != 0:
organisation_dto.is_manager = OrganisationService.can_user_manage_organisation(
organisation_id, user_id)
else:
organisation_dto.is_manager = False
teams = OrganisationService.get_teams_by_organisation_id(
organisation_id)
for team in teams:
organisation_dto.teams.append(team.as_dto_inside_org())
projects = OrganisationService.get_projects_by_organisation_id(
organisation_id)
for project in projects:
organisation_dto.projects.append([project.id, project.name])
return organisation_dto
def check_draft_project_visibility(self, authenticated_user_id: int):
"""" Check if a User is allowed to see a Draft Project """
is_allowed_user = False
if authenticated_user_id:
is_team_manager = False
user = User.get_by_id(authenticated_user_id)
user_orgs = Organisation.get_organisations_managed_by_user(
authenticated_user_id
)
if self.teams:
for project_team in self.teams:
team_members = Team.get(project_team.team_id)._get_team_members()
for member in team_members:
if (
user.username == member["username"]
and member["function"] == TeamMemberFunctions.MANAGER.name
):
is_team_manager = True
break
if (
UserRole(user.role) == UserRole.ADMIN
or authenticated_user_id == self.author_id
or self.organisation in user_orgs
or is_team_manager
):
is_allowed_user = True
return is_allowed_user
def get_organisation_by_id_as_dto(
organisation_id: int, user_id: int, abbreviated: bool
):
org = Organisation.get(organisation_id)
if org is None:
raise NotFound()
organisation_dto = org.as_dto(abbreviated)
if user_id != 0:
organisation_dto.is_manager = (
OrganisationService.can_user_manage_organisation(
organisation_id, user_id
)
)
else:
organisation_dto.is_manager = False
if abbreviated:
return organisation_dto
organisation_dto.teams = [team.as_dto_inside_org() for team in org.teams]
return organisation_dto
def is_user_an_org_manager(organisation_id: int, user_id: int):
""" Check that the user is an manager for the org """
org = Organisation.get(organisation_id)
if org is None:
raise NotFound()
user = UserService.get_user_by_id(user_id)
return user in org.managers
def create_organisation(new_organisation_dto: NewOrganisationDTO) -> int:
"""
Creates a new organisation using an organisation dto
:param new_organisation_dto: Organisation DTO
:returns: ID of new Organisation
"""
try:
org = Organisation.create_from_dto(new_organisation_dto)
return org.id
except IntegrityError:
raise OrganisationServiceError(
f"Organisation name already exists: {new_organisation_dto.name}"
)
def update(self, team_dto: TeamDTO):
""" Updates Team from DTO """
if team_dto.organisation:
self.organisation = Organisation().get_organisation_by_name(
team_dto.organisation)
for attr, value in team_dto.items():
if attr == "visibility" and value is not None:
value = TeamVisibility[team_dto.visibility].value
if attr in ("members", "organisation"):
continue
try:
is_field_nullable = self.__table__.columns[attr].nullable
if is_field_nullable and value is not None:
setattr(self, attr, value)
elif value is not None:
setattr(self, attr, value)
except KeyError:
continue
if team_dto.members != self._get_team_members() and team_dto.members:
for member in self.members:
db.session.delete(member)
for member in team_dto.members:
user = User.get_by_username(member["userName"])
if user is None:
raise NotFound("User not found")
new_team_member = TeamMembers()
new_team_member.team = self
new_team_member.member = user
new_team_member.function = TeamMemberFunctions[
member["function"]].value
db.session.commit()
def create_from_dto(cls, new_team_dto: NewTeamDTO):
""" Creates a new team from a dto """
new_team = cls()
new_team.name = new_team_dto.name
new_team.description = new_team_dto.description
new_team.invite_only = new_team_dto.invite_only
new_team.visibility = TeamVisibility[new_team_dto.visibility].value
org = Organisation.get(new_team_dto.organisation_id)
new_team.organisation = org
# Create team member with creator as a manager
new_member = TeamMembers()
new_member.team = new_team
new_member.user_id = new_team_dto.creator
new_member.function = TeamMemberFunctions.MANAGER.value
new_member.active = True
new_team.members.append(new_member)
new_team.create()
return new_team
def update(self, project_dto: ProjectDTO):
""" Updates project from DTO """
self.status = ProjectStatus[project_dto.project_status].value
self.priority = ProjectPriority[project_dto.project_priority].value
self.default_locale = project_dto.default_locale
self.enforce_random_task_selection = project_dto.enforce_random_task_selection
self.private = project_dto.private
self.mapper_level = MappingLevel[
project_dto.mapper_level.upper()].value
self.changeset_comment = project_dto.changeset_comment
self.due_date = project_dto.due_date
self.imagery = project_dto.imagery
self.josm_preset = project_dto.josm_preset
self.id_presets = project_dto.id_presets
self.last_updated = timestamp()
self.license_id = project_dto.license_id
if project_dto.osmcha_filter_id:
# Support simple extraction of OSMCha filter id from OSMCha URL
match = re.search(r"aoi=([\w-]+)", project_dto.osmcha_filter_id)
self.osmcha_filter_id = (match.group(1) if match else
project_dto.osmcha_filter_id)
else:
self.osmcha_filter_id = None
if project_dto.organisation:
org = Organisation.get(project_dto.organisation)
if org is None:
raise NotFound("Organisation does not exist")
self.organisation = org
# Cast MappingType strings to int array
type_array = []
for mapping_type in project_dto.mapping_types:
type_array.append(MappingTypes[mapping_type].value)
self.mapping_types = type_array
# Cast Editor strings to int array
mapping_editors_array = []
for mapping_editor in project_dto.mapping_editors:
mapping_editors_array.append(Editors[mapping_editor].value)
self.mapping_editors = mapping_editors_array
validation_editors_array = []
for validation_editor in project_dto.validation_editors:
validation_editors_array.append(Editors[validation_editor].value)
self.validation_editors = validation_editors_array
self.country = project_dto.country_tag
# Add list of allowed users, meaning the project can only be mapped by users in this list
if hasattr(project_dto, "allowed_users"):
self.allowed_users = [
] # Clear existing relationships then re-insert
for user in project_dto.allowed_users:
self.allowed_users.append(user)
# Update teams and projects relationship.
self.teams = []
if hasattr(project_dto, "project_teams") and project_dto.project_teams:
for team_dto in project_dto.project_teams:
team = Team.get(team_dto.team_id)
if team is None:
raise NotFound("Team not found")
role = TeamRoles[team_dto.role].value
ProjectTeams(project=self, team=team, role=role)
# Set Project Info for all returned locales
for dto in project_dto.project_info_locales:
project_info = self.project_info.filter_by(
locale=dto.locale).one_or_none()
if project_info is None:
new_info = ProjectInfo.create_from_dto(
dto) # Can't find info so must be new locale
self.project_info.append(new_info)
else:
project_info.update_from_dto(dto)
self.priority_areas = [
] # Always clear Priority Area prior to updating
if project_dto.priority_areas:
for priority_area in project_dto.priority_areas:
pa = PriorityArea.from_dict(priority_area)
self.priority_areas.append(pa)
if project_dto.custom_editor:
if not self.custom_editor:
new_editor = CustomEditor.create_from_dto(
self.id, project_dto.custom_editor)
self.custom_editor = new_editor
else:
self.custom_editor.update_editor(project_dto.custom_editor)
else:
if self.custom_editor:
self.custom_editor.delete()
# handle campaign update
try:
new_ids = [c.id for c in project_dto.campaigns]
new_ids.sort()
except TypeError:
new_ids = []
current_ids = [c.id for c in self.campaign]
current_ids.sort()
if new_ids != current_ids:
self.campaign = Campaign.query.filter(
Campaign.id.in_(new_ids)).all()
if project_dto.mapping_permission:
self.mapping_permission = MappingPermission[
project_dto.mapping_permission.upper()].value
if project_dto.validation_permission:
self.validation_permission = ValidationPermission[
project_dto.validation_permission.upper()].value
# handle interests update
try:
new_ids = [c.id for c in project_dto.interests]
new_ids.sort()
except TypeError:
new_ids = []
current_ids = [c.id for c in self.interests]
current_ids.sort()
if new_ids != current_ids:
self.interests = Interest.query.filter(
Interest.id.in_(new_ids)).all()
# try to update country info if that information is not present
if not self.country:
self.set_country_info()
db.session.commit()
def get_organisation_name_by_id(organisation_id: int) -> str:
return Organisation.get_organisation_name_by_id(organisation_id)
def assert_validate_name(org: Organisation, name: str):
""" Validates that the organisation name doesn't exist """
if org.name != name and Organisation.get_organisation_by_name(
name) is not None:
raise OrganisationServiceError(
f"Organisation name already exists: {name}")
def get_organisations_managed_by_user(user_id: int):
""" Get all organisations a user manages """
if UserService.is_user_an_admin(user_id):
return Organisation.get_all_organisations()
return Organisation.get_organisations_managed_by_user(user_id)
def get_organisation_by_id_as_dto(organisation_id: int, user_id: int,
abbreviated: bool):
org = Organisation.get(organisation_id)
return OrganisationService.get_organisation_dto(
org, user_id, abbreviated)
