def update_stats_after_task_state_change(
project_id: int,
user_id: int,
last_state: TaskStatus,
new_state: TaskStatus,
action="change",
):
""" Update stats when a task has had a state change """
if new_state in [
TaskStatus.READY,
TaskStatus.LOCKED_FOR_VALIDATION,
TaskStatus.LOCKED_FOR_MAPPING,
]:
return # No stats to record for these states
project = ProjectService.get_project_by_id(project_id)
user = UserService.get_user_by_id(user_id)
project, user = StatsService._update_tasks_stats(
project, user, last_state, new_state, action)
UserService.upsert_mapped_projects(user_id, project_id)
project.last_updated = timestamp()
# Transaction will be saved when task is saved
return project, user
def update_stats_after_task_state_change(project_id: int, user_id: int,
new_state: TaskStatus,
task_id: int):
""" Update stats when a task has had a state change """
if new_state in [
TaskStatus.READY, TaskStatus.LOCKED_FOR_VALIDATION,
TaskStatus.LOCKED_FOR_MAPPING
]:
return # No stats to record for these states
project = ProjectService.get_project_by_id(project_id)
user = UserService.get_user_by_id(user_id)
if new_state == TaskStatus.MAPPED:
StatsService._set_counters_after_mapping(project, user)
elif new_state == TaskStatus.INVALIDATED:
StatsService._set_counters_after_invalidated(
task_id, project, user)
elif new_state == TaskStatus.VALIDATED:
StatsService._set_counters_after_validated(project, user)
elif new_state == TaskStatus.BADIMAGERY:
StatsService._set_counters_after_bad_imagery(project)
UserService.upsert_mapped_projects(user_id, project_id)
project.last_updated = timestamp()
# Transaction will be saved when task is saved
return project, user
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_mapper_level = project_dto.enforce_mapper_level
self.enforce_validator_role = project_dto.enforce_validator_role
self.private = project_dto.private
self.mapper_level = MappingLevel[project_dto.mapper_level.upper()].value
self.entities_to_map = project_dto.entities_to_map
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.last_updated = timestamp()
self.license_id = project_dto.license_id
if project_dto.organisation_tag:
org_tag = Tags.upsert_organistion_tag(project_dto.organisation_tag)
self.organisation_tag = org_tag
else:
self.organisation_tag = None # Set to none, for cases where a tag could have been removed
if project_dto.campaign_tag:
camp_tag = Tags.upsert_campaign_tag(project_dto.campaign_tag)
self.campaign_tag = camp_tag
else:
self.campaign_tag = None # Set to none, for cases where a tag could have been removed
# 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
# 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)
# 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)
db.session.commit()
def clone(project_id: int, author_id: int):
""" Clone project """
cloned_project = Project.get(project_id)
# Remove clone from session so we can reinsert it as a new object
db.session.expunge(cloned_project)
make_transient(cloned_project)
# Re-initialise counters and meta-data
cloned_project.total_tasks = 0
cloned_project.tasks_mapped = 0
cloned_project.tasks_validated = 0
cloned_project.tasks_bad_imagery = 0
cloned_project.last_updated = timestamp()
cloned_project.created = timestamp()
cloned_project.author_id = author_id
cloned_project.status = ProjectStatus.DRAFT.value
cloned_project.id = None # Reset ID so we get a new ID when inserted
cloned_project.geometry = None
cloned_project.centroid = None
db.session.add(cloned_project)
db.session.commit()
# Now add the project info, we have to do it in a two stage commit because we need to know the new project id
original_project = Project.get(project_id)
for info in original_project.project_info:
db.session.expunge(info)
make_transient(
info
) # Must remove the object from the session or it will be updated rather than inserted
info.id = None
info.project_id_str = str(cloned_project.id)
cloned_project.project_info.append(info)
# Now add allowed users now we know new project id, if there are any
for user in original_project.allowed_users:
cloned_project.allowed_users.append(user)
db.session.add(cloned_project)
db.session.commit()
return cloned_project
def unlock_tasks_after_validation(
validated_dto: UnlockAfterValidationDTO) -> TaskDTOs:
"""
Unlocks supplied tasks after validation
:raises ValidatatorServiceError
"""
validated_tasks = validated_dto.validated_tasks
project_id = validated_dto.project_id
user_id = validated_dto.user_id
tasks_to_unlock = ValidatorService.get_tasks_locked_by_user(
project_id, validated_tasks, user_id)
# Unlock all tasks
dtos = []
message_sent_to = []
for task_to_unlock in tasks_to_unlock:
task = task_to_unlock['task']
if task_to_unlock['comment']:
# Parses comment to see if any users have been @'d
MessageService.send_message_after_comment(
validated_dto.user_id, task_to_unlock['comment'], task.id,
validated_dto.project_id)
if task_to_unlock[
'new_state'] == TaskStatus.VALIDATED or task_to_unlock[
'new_state'] == TaskStatus.INVALIDATED:
# All mappers get a notification if their task has been validated or invalidated.
# Only once if multiple tasks mapped
if task.mapped_by not in message_sent_to:
MessageService.send_message_after_validation(
task_to_unlock['new_state'], validated_dto.user_id,
task.mapped_by, task.id, validated_dto.project_id)
message_sent_to.append(task.mapped_by)
if task_to_unlock['new_state'] == TaskStatus.VALIDATED:
# Set last_validation_date for the mapper to current date
task.mapper.last_validation_date = timestamp()
# Update stats if user setting task to a different state from previous state
prev_status = TaskHistory.get_last_status(project_id, task.id)
if prev_status != task_to_unlock['new_state']:
StatsService.update_stats_after_task_state_change(
validated_dto.project_id, validated_dto.user_id,
prev_status, task_to_unlock['new_state'])
task_mapping_issues = ValidatorService.get_task_mapping_issues(
task_to_unlock)
task.unlock_task(validated_dto.user_id,
task_to_unlock['new_state'],
task_to_unlock['comment'],
issues=task_mapping_issues)
dtos.append(
task.as_dto_with_instructions(validated_dto.preferred_locale))
task_dtos = TaskDTOs()
task_dtos.tasks = dtos
return task_dtos
def create_draft_project(self, draft_project_dto: DraftProjectDTO):
"""
Creates a draft project
:param draft_project_dto: DTO containing draft project details
:param aoi: Area of Interest for the project (eg boundary of project)
"""
self.project_info.append(ProjectInfo.create_from_name(draft_project_dto.project_name))
self.status = ProjectStatus.DRAFT.value
self.author_id = draft_project_dto.user_id
self.last_updated = timestamp()
def create_draft_project(self, draft_project_dto: DraftProjectDTO, aoi: AreaOfInterest):
"""
Creates a draft project
:param draft_project_dto: DTO containing draft project details
:param aoi: Area of Interest for the project (eg boundary of project)
"""
self.project_info.append(ProjectInfo.create_from_name(draft_project_dto.project_name))
self.area_of_interest = aoi
self.status = ProjectStatus.DRAFT.value
self.author_id = draft_project_dto.user_id
self.last_updated = timestamp()
self.changeset_comment = current_app.config['DEFAULT_CHANGESET_COMMENT']
def record_invalidation(project_id, task_id, invalidator_id, history):
# Invalidation always kicks off a new entry for a task, so close any existing ones.
TaskInvalidationHistory.close_all_for_task(project_id, task_id)
last_mapped = TaskHistory.get_last_mapped_action(project_id, task_id)
entry = TaskInvalidationHistory(project_id, task_id)
entry.invalidation_history_id = history.id
entry.mapper_id = last_mapped.user_id
entry.mapped_date = last_mapped.action_date
entry.invalidator_id = invalidator_id
entry.invalidated_date = history.action_date
entry.updated_date = timestamp()
db.session.add(entry)
def record_validation(project_id, task_id, validator_id, history):
entry = TaskInvalidationHistory.get_open_for_task(project_id, task_id)
# If no open invalidation to update, then nothing to do
if entry is None:
return
last_mapped = TaskHistory.get_last_mapped_action(project_id, task_id)
entry.mapper_id = last_mapped.user_id
entry.mapped_date = last_mapped.action_date
entry.validator_id = validator_id
entry.validated_date = history.action_date
entry.is_closed = True
entry.updated_date = timestamp()
def add_or_update_annotation(annotation, project_id, annotation_type):
""" Takes a json of tasks and create annotations in the db """
task_id = annotation['taskId']
source = annotation.get('annotationSource', None)
markdown = annotation.get('annotationMarkdown', None)
task_annotation = TaskAnnotation(task_id, project_id, annotation_type,
annotation['properties'], source,
markdown)
# check if the task has this annotation_type
existing_annotation = TaskAnnotation.get_task_annotation(
task_id, project_id, annotation_type)
if (existing_annotation):
# update this annotation
existing_annotation.properties = task_annotation.properties
existing_annotation.updated_timestamp = timestamp()
existing_annotation.update()
else:
# add this annotation
task_annotation.create()
def clone(project_id: int, author_id: int):
""" Clone project """
cloned_project = Project.get(project_id)
# Remove clone from session so we can reinsert it as a new object
db.session.expunge(cloned_project)
make_transient(cloned_project)
# Re-initialise counters and meta-data
cloned_project.total_tasks = 0
cloned_project.tasks_mapped = 0
cloned_project.tasks_validated = 0
cloned_project.tasks_bad_imagery = 0
cloned_project.last_updated = timestamp()
cloned_project.created = timestamp()
cloned_project.author_id = author_id
cloned_project.status = ProjectStatus.DRAFT.value
cloned_project.id = None # Reset ID so we get a new ID when inserted
cloned_project.geometry = None
cloned_project.centroid = None
db.session.add(cloned_project)
db.session.commit()
# Now add the project info, we have to do it in a two stage commit because we need to know the new project id
original_project = Project.get(project_id)
for info in original_project.project_info:
db.session.expunge(info)
make_transient(info) # Must remove the object from the session or it will be updated rather than inserted
info.id = None
info.project_id_str = str(cloned_project.id)
cloned_project.project_info.append(info)
# Now add allowed users now we know new project id, if there are any
for user in original_project.allowed_users:
cloned_project.allowed_users.append(user)
# Add other project metadata
cloned_project.priority = original_project.priority
cloned_project.default_locale = original_project.default_locale
cloned_project.mapper_level = original_project.mapper_level
cloned_project.enforce_mapper_level = original_project.enforce_mapper_level
cloned_project.enforce_validator_role = original_project.enforce_validator_role
cloned_project.enforce_random_task_selection = original_project.enforce_random_task_selection
cloned_project.private = original_project.private
cloned_project.entities_to_map = original_project.entities_to_map
cloned_project.due_date = original_project.due_date
cloned_project.imagery = original_project.imagery
cloned_project.josm_preset = original_project.josm_preset
cloned_project.license_id = original_project.license_id
cloned_project.mapping_types = original_project.mapping_types
cloned_project.organisation_tag = original_project.organisation_tag
cloned_project.campaign_tag = original_project.campaign_tag
# We try to remove the changeset comment referencing the old project. This
# assumes the default changeset comment has not changed between the old
# project and the cloned. This is a best effort basis.
default_comment = current_app.config['DEFAULT_CHANGESET_COMMENT']
changeset_comments = []
if original_project.changeset_comment is not None:
changeset_comments = original_project.changeset_comment.split(' ')
if f'{default_comment}-{original_project.id}' in changeset_comments:
changeset_comments.remove(f'{default_comment}-{original_project.id}')
cloned_project.changeset_comment = " ".join(changeset_comments)
db.session.add(cloned_project)
db.session.commit()
return cloned_project
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_mapper_level = project_dto.enforce_mapper_level
self.enforce_validator_role = project_dto.enforce_validator_role
self.enforce_random_task_selection = project_dto.enforce_random_task_selection
self.allow_non_beginners = project_dto.allow_non_beginners
self.private = project_dto.private
self.mapper_level = MappingLevel[
project_dto.mapper_level.upper()].value
self.entities_to_map = project_dto.entities_to_map
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('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_tag:
org_tag = Tags.upsert_organistion_tag(project_dto.organisation_tag)
self.organisation_tag = org_tag
else:
self.organisation_tag = None # Set to none, for cases where a tag could have been removed
if project_dto.campaign_tag:
camp_tag = Tags.upsert_campaign_tag(project_dto.campaign_tag)
self.campaign_tag = camp_tag
else:
self.campaign_tag = None # Set to none, for cases where a tag could have been removed
# 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
# 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)
# 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()
db.session.commit()
