def get(self, project_id):
"""
Get latest user activity on all of project task
---
tags:
- projects
produces:
- application/json
parameters:
- name: project_id
in: path
required: true
type: integer
default: 1
responses:
200:
description: Project activity
404:
description: No activity
500:
description: Internal Server Error
"""
try:
ProjectService.exists(project_id)
except NotFound as e:
current_app.logger.error(f"Error validating project: {str(e)}")
return {"Error": "Project not found"}, 404
try:
activity = StatsService.get_last_activity(project_id)
return activity.to_primitive(), 200
except Exception as e:
error_msg = f"User GET - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": "Unable to fetch user activity"}, 500
def get(self, project_id):
"""
Get all chat messages for a project
---
tags:
- comments
produces:
- application/json
parameters:
- name: project_id
in: path
description: Project ID to attach the chat message to
required: true
type: integer
default: 1
- in: query
name: page
description: Page of results user requested
type: integer
default: 1
- in: query
name: perPage
description: Number of elements per page.
type: integer
default: 20
responses:
200:
description: All messages
404:
description: No chat messages on project
500:
description: Internal Server Error
"""
try:
ProjectService.exists(project_id)
except NotFound as e:
current_app.logger.error(f"Error validating project: {str(e)}")
return {"Error": "Project not found"}, 404
try:
page = int(
request.args.get("page")) if request.args.get("page") else 1
per_page = int(request.args.get("perPage", 20))
project_messages = ChatService.get_messages(
project_id, page, per_page)
return project_messages.to_primitive(), 200
except NotFound:
return {"Error": "Project not found"}, 404
except Exception as e:
error_msg = f"Chat GET - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": "Unable to fetch chat messages"}, 500
def get_latest_activity(project_id: int, page: int) -> ProjectActivityDTO:
""" Gets all the activity on a project """
if not ProjectService.exists(project_id):
raise NotFound
results = (db.session.query(
TaskHistory.id,
TaskHistory.task_id,
TaskHistory.action,
TaskHistory.action_date,
TaskHistory.action_text,
User.username,
).join(User).filter(TaskHistory.project_id == project_id,
TaskHistory.action != "COMMENT").order_by(
TaskHistory.action_date.desc()).paginate(
page, 10, True))
activity_dto = ProjectActivityDTO()
for item in results.items:
history = TaskHistoryDTO()
history.task_id = item.id
history.task_id = item.task_id
history.action = item.action
history.action_text = item.action_text
history.action_date = item.action_date
history.action_by = item.username
activity_dto.activity.append(history)
activity_dto.pagination = Pagination(results)
return activity_dto
def get(self, project_id: int, annotation_type: str = None):
"""
Get all task annotations for a project
---
tags:
- annotations
produces:
- application/json
parameters:
- name: project_id
in: path
description: The ID of the project
required: true
type: integer
- name: annotation_type
in: path
description: The type of annotation to fetch
required: false
type: integer
responses:
200:
description: Project Annotations
404:
description: Project or annotations not found
500:
description: Internal Server Error
"""
try:
ProjectService.exists(project_id)
except NotFound as e:
current_app.logger.error(f"Error validating project: {str(e)}")
return {"Error": "Project not found"}, 404
try:
if annotation_type:
annotations = TaskAnnotation.get_task_annotations_by_project_id_type(
project_id, annotation_type
)
else:
annotations = TaskAnnotation.get_task_annotations_by_project_id(
project_id
)
return annotations.to_primitive(), 200
except NotFound:
return {"Error": "Annotations not found"}, 404
def get(self, project_id):
"""
Get all user activity on a project
---
tags:
- projects
produces:
- application/json
parameters:
- name: project_id
in: path
description: Unique project ID
required: true
type: integer
default: 1
- in: query
name: page
description: Page of results user requested
type: integer
responses:
200:
description: Project activity
404:
description: No activity
500:
description: Internal Server Error
"""
try:
ProjectService.exists(project_id)
except NotFound as e:
current_app.logger.error(f"Error validating project: {str(e)}")
return {"Error": "Project not found"}, 404
try:
page = int(
request.args.get("page")) if request.args.get("page") else 1
activity = StatsService.get_latest_activity(project_id, page)
return activity.to_primitive(), 200
except Exception as e:
error_msg = f"User GET - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": "Unable to fetch user activity"}, 500
def get(self, project_id):
"""
Get all user contributions on a project
---
tags:
- projects
produces:
- application/json
parameters:
- name: project_id
in: path
description: Unique project ID
required: true
type: integer
default: 1
responses:
200:
description: User contributions
404:
description: No contributions
500:
description: Internal Server Error
"""
try:
ProjectService.exists(project_id)
except NotFound as e:
current_app.logger.error(f"Error validating project: {str(e)}")
return {"Error": "Project not found"}, 404
try:
contributions = StatsService.get_user_contributions(project_id)
return contributions.to_primitive(), 200
except Exception as e:
error_msg = f"User GET - unhandled error: {str(e)}"
current_app.logger.critical(error_msg)
return {"Error": "Unable to fetch user contributions"}, 500
def post(self, project_id: int, annotation_type: str):
"""
Store new task annotations for tasks of a project
---
tags:
- annotations
produces:
- application/json
parameters:
- in: header
name: Content-Type
description: Content type for post body
required: true
type: string
default: application/json
- name: project_id
in: path
description: Unique project ID
required: true
type: integer
- name: annotation_type
in: path
description: Annotation type
required: true
type: string
- name: Application-Token
in: header
description: Application token registered with TM
required: true
type: string
- in: body
name: body
required: true
description: JSON object for creating draft project
schema:
projectId:
type: integer
required: true
annotationType:
type: string
required: true
tasks:
type: array
required: true
items:
schema:
taskId:
type: integer
required: true
annotationSource:
type: string
annotationMarkdown:
type: string
properties:
description: JSON object with properties
responses:
200:
description: Project updated
400:
description: Client Error - Invalid Request
404:
description: Project or task not found
500:
description: Internal Server Error
"""
if "Application-Token" in request.headers:
application_token = request.headers["Application-Token"]
try:
is_valid_token = ApplicationService.check_token( # noqa
application_token
)
except NotFound:
current_app.logger.error("Invalid token")
return {"Error": "Invalid token"}, 500
else:
current_app.logger.error("No token supplied")
return {"Error": "No token supplied"}, 500
try:
annotations = request.get_json() or {}
except DataError as e:
current_app.logger.error(f"Error validating request: {str(e)}")
try:
ProjectService.exists(project_id)
except NotFound as e:
current_app.logger.error(f"Error validating project: {str(e)}")
return {"Error": "Project not found"}, 404
task_ids = [t["taskId"] for t in annotations["tasks"]]
# check if task ids are valid
tasks = Task.get_tasks(project_id, task_ids)
tasks_ids_db = [t.id for t in tasks]
if len(task_ids) != len(tasks_ids_db):
return {"Error": "Invalid task id"}, 500
for annotation in annotations["tasks"]:
try:
TaskAnnotationsService.add_or_update_annotation(
annotation, project_id, annotation_type
)
except DataError as e:
current_app.logger.error(f"Error creating annotations: {str(e)}")
return {"Error": "Error creating annotations"}, 500
return project_id, 200