def get(self, *args, **kwargs):
'''
The get URL should be :
/project/<project-name>/stitch/
get data format = {
x: x_xordinate,
y: y_cordinate,
image: current_image_file_name
}
'''
super(Stitch, self).get(*args, **kwargs)
data = {}
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
title = kwargs.get('project', None)
if not title:
data['status'] = 400
data['message'] = 'Bad Request.'
else:
x = self.get_argument('x', None)
y = self.get_argument('y', None)
flag = x and y
project = None
image = None
from_image = self.get_argument('image', None)
try:
project = Project.objects.get(title=title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid project title.'
if project:
try:
image = Image.objects.get(project=project,
name=from_image)
except Image.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Image.'
if image:
hotspots = Hotspot.objects.filter(project=project,
image=image)
if flag:
[self._x1, self._y1] = [int(x), int(y)]
closest_hotspot = self.get_hotspot_object(hotspots)
if closest_hotspot:
data['status'] = 200
data['closests_hotspot'] = json_dumper(closest_hotspot)
else:
data['status'] = 404
data['message'] = 'No hotspot at this coordinate.'
else:
data['status'] = 200
data['hotspots'] = json_dumper(hotspots)
# added condition check for hotspot-edit as the hotspot handler is
# inheriting this handler.
if not self._headers_written and 'hotspot-edit' not in self.request.uri:
self.write(data)
def post(self, *args, **kwargs):
super(ProjectHandler, self).post(*args, **kwargs)
data = {}
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
# Project.objects.delete()
# Image.objects.delete()
post_data = ast.literal_eval(self.data)
if 'project_data' not in post_data.keys():
data['status'] = 500
data['message'] = 'Invalid data.'
else:
post_data['project_data'] = ast.literal_eval(post_data['project_data'])
try:
title = post_data['project_data']['path'].strip('/')
self._project = Project.objects.create(
created_by=self.user,
title=title,
is_active=True,
metadata=post_data['project_data'])
self._project.save()
except OperationError, e:
data['status'] = 400
data['message'] = 'Bad Request.'
data['information'] = 'This project already exists.'
if self._project:
image_list = []
path = self._project.metadata['path']
subfolder_data = self.dropbox_client.metadata(path)
images = [x for x in subfolder_data['contents'] if (
'mime_type'in x.keys() and x['mime_type']
in IMAGE_MIME_TYPE)]
t_image = []
screen_count = 0
for (count, each) in enumerate(images):
image_object = self.create_image_object(each)
if image_object:
t_image = image_object
screen_count = count
image_list.append(json_dumper(image_object))
if t_image:
data['thumbnail'] = t_image.thumbnail
data['name'] = t_image.name
data['screen_count'] = screen_count + 1
else:
data['thumbnail'] = None
data['status'] = 200
data['project'] = json_dumper(self._project)
data['images'] = self.getThumbnailSlug(image_list)
data['image_count'] = len(images)
def get(self,*args, **kwargs):
project_id = self.get_argument('projectId', None)
project = self.get_project_object(project_id=project_id,
permalink=None)
self.project = project
response = {}
members = list(Team.objects.filter(project=project).exclude("project",
"created_by", "updated_by"))
invited_members = list(Invitation.objects.filter(project=project
).exclude('invited_by', 'project'))
response['members'] = json_dumper(members)
response['invited_members'] = json_dumper(invited_members)
self.write(json.dumps(response))
def get(self, *args, **kwargs):
'''
Method to get comments , annotation and their replies for an image.
url: /project/<project-name>/image/<image-name>/
'''
super(UpdateHandler, self).get(*args, **kwargs)
data = self._data
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
title = kwargs.get('project', None)
image_name = kwargs.get('image', None)
image = None
if not title or not image_name:
data['status'] = 400
data['message'] = 'Bad Request'
else:
try:
self._project = Project.objects.get(title=title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid project title.'
if self._project:
try:
image = Image.objects.get(project=self._project,
name=image_name)
except Image.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid image'
if image:
comments = Comment.objects.filter(image=image
).order_by('-updated_on')
annotations = Annotation.objects.filter(image=image
).order_by('-updated_on')
ordered_list = list(comments)
ordered_list.extend(annotations)
ordered_list = merge_sort(ordered_list)
data['status'] = 200
data['image'] = json_dumper(image)
data['updates'] = json_dumper(ordered_list)
if not self._headers_written:
self.write(data)
def get(self,*args, **kwargs):
project_id = self.get_argument('projectId', None)
project = self.get_project_object(project_id=project_id,
permalink=None)
members = list(Team.objects.filter(project=project).exclude("project",
"created_by", "updated_by"))
self.write(json.dumps(json_dumper(members)))
def get(self, *args, **kwargs):
project_id = self.get_argument('projectId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
project_permalink = self.get_argument('project_pemalink', None)
project = None
response = {}
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_valid_project(project_id, permalink)
elif project_permalink:
project = self.get_valid_project(project_id=None,
permalink=project_permalink)
else:
self.send_error(400)
roles = Role.objects.filter(project=project).exclude(
'created_by', 'updated_by', 'project', 'updated_on', 'created_on')
response['roles'] = json_dumper(list(roles))
response['available_roles'] = [
role for role in TEAM_ROLES if role not in response['roles']
]
response['permissions'] = PROJECT_PERMISSIONS
d = {}
[
d.update({role.role: self.generate_readable_permission_json(role)})
for role in roles
]
response['project_permissions_map'] = d
self.write(json.dumps(response))
def get(self,*args, **kwargs):
'''
taskId will be that of a parent task.
This handler will return comments of a task which is always tied
up to a parent task.
'''
project_id = self.get_argument('projectId', None)
task_id = self.get_argument('taskId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
project = None
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_project_object(project_id=None,
permalink=permalink)
else:
self.send_error(400)
response = {}
task = self.get_task_object(project, task_id)
if not task:
raise HTTPError(404, **{'reason': 'Task not found'})
else:
response['task'] = task.to_json()
response['task_type'] = TASK_TYPES
response['task_comments'] = json_dumper(
list(TaskUpdate.objects.filter(task=task,
is_active=True).order_by('-id')))
self.finish(json.dumps(response))
def get(self, *args, **kwargs):
project_id = self.get_argument('projectId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
project_permalink = self.get_argument('project_pemalink', None)
project = None
response = {}
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_valid_project(project_id, permalink)
elif project_permalink:
project = self.get_valid_project(project_id=None,
permalink=project_permalink)
else:
self.send_error(400)
roles = Role.objects.filter(project=project
).exclude('created_by', 'updated_by',
'project', 'updated_on',
'created_on')
response['roles'] = json_dumper(list(roles))
response['available_roles'] = [role for role in TEAM_ROLES
if role not in response['roles']]
response['permissions'] = PROJECT_PERMISSIONS
d = {}
[d.update({role.role: self.generate_readable_permission_json(role)})
for role in roles]
response['project_permissions_map'] = d
self.write(json.dumps(response))
def get(self, *args, **kwargs):
'''
taskId will be that of a parent task.
This handler will return comments of a task which is always tied
up to a parent task.
'''
project_id = self.get_argument('projectId', None)
task_id = self.get_argument('taskId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
project = None
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_project_object(project_id=None,
permalink=permalink)
else:
self.send_error(400)
response = {}
task = self.get_task_object(project, task_id)
if not task:
raise HTTPError(404, **{'reason': 'Task not found'})
else:
response['task'] = task.to_json()
response['task_type'] = TASK_TYPES
response['task_comments'] = json_dumper(
list(
TaskUpdate.objects.filter(task=task,
is_active=True).order_by('-id')))
self.finish(json.dumps(response))
def get(self, *args, **kwargs):
'''
Notifications can be fetch in bulk by the websocket
so that we need to make multiple API calls for every
user. In that case, we expect a multiple params with the
key user and the value as user_id, last_notification_id
Ex: /notification/?user=1,613434&user=2,8980978907&user=3,707093
We will then fetch the notifications for each user, and respond
'''
response = {}
users = self.get_arguments('user', None)
'''
If we have multiple users, loop through the list, and fetch
the notifications for each user
'''
if users:
qParams = {
'is_read': False
}
for user in users:
if ',' in user:
user_id, last_notification_id = user.split(',')
qParams['for_user'] = user_id
qParams['id__gt'] = last_notification_id
else:
qParams['for_user'] = user
user_notification = Notification.objects(**qParams)\
.order_by('-id')
response[qParams['for_user']] = json_dumper(user_notification)
elif self.current_user:
qParams = {
'for_user': self.current_user
}
last_id = self.get_argument('last_id', None)
if last_id:
qParams['id__gt'] = last_id
qParams['is_read'] = False
notifications = Notification.objects(**qParams)\
.order_by('-id')[self._limit_from:self._limit_to]
response = json_dumper(notifications)
self.finish(json.dumps(response))
def get(self,*args, **kwargs):
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
project_id = self.get_argument('projectId', None)
sprint_sequence = self.get_argument('sprint',None)
response = {}
project = self.get_valid_project(project_id, org)
if not sprint_sequence:
sprints = list(Sprint.objects.filter(project=project))
response['sprints'] = json_dumper(sprints)
elif sprint_sequence:
try:
sprint = project.get_sprint_object(sprint_sequence)
response['sprint'] = sprint.to_json()
response['stories'] = json_dumper(list(sprint.get_stories()))
except ValidationError, error:
raise HTTPError(404, **{'reason': self.error_message(error)})
def get(self, *args, **kwargs):
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
project_id = self.get_argument('projectId', None)
sprint_sequence = self.get_argument('sprint', None)
response = {}
project = self.get_valid_project(project_id, org)
if not sprint_sequence:
sprints = list(Sprint.objects.filter(project=project))
response['sprints'] = json_dumper(sprints)
elif sprint_sequence:
try:
sprint = project.get_sprint_object(sprint_sequence)
response['sprint'] = sprint.to_json()
response['stories'] = json_dumper(list(sprint.get_stories()))
except ValidationError, error:
raise HTTPError(404, **{'reason': self.error_message(error)})
def get(self, *args, **kwargs):
code = self.get_argument('code')
invitation = None
try:
invitation = Invitation.objects.get(
code=code, valid_until__gte=datetime.utcnow())
self.write(json_dumper(invitation))
except Invitation.DoesNotExist:
raise HTTPError(404, **{'reason': "Invalid token"})
def get(self, *args, **kwargs):
code = self.get_argument('code')
invitation = None
try:
invitation = Invitation.objects.get(code=code,
valid_until__gte=datetime.utcnow())
self.write(json_dumper(invitation))
except Invitation.DoesNotExist:
raise HTTPError(404, **{'reason': "Invalid token"})
def get(self,*args, **kwargs):
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
project_id = self.get_argument('projectId', None)
if not project_id:
self.send_error(404)
else:
project = self.get_project_object(project_id, org)
members = [user for user in project.members]
self.write(json.dumps(json_dumper(members)))
def get(self, *args, **kwargs):
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
project_id = self.get_argument('projectId', None)
if not project_id:
self.send_error(404)
else:
project = self.get_project_object(project_id, org)
members = [user for user in project.members]
self.write(json.dumps(json_dumper(members)))
def get(self, *args, **kwargs):
users = User.objects.only("username","email")
unique_sessions = {}
sessions = Session.objects(user__in=users).order_by("generated_at")
# we now have to group the sessions by username,
for username, sess in groupby(sessions, lambda x: x['user']['username']):
#print "%s has %d sessions" %(username, len(list(sess)))
unique_sessions[username] = list(sess)[-1].to_json()
projects = Project.objects.only(
"title","permalink","description","members"
)
self.write({
'users': json_dumper(users, fields=['username','email']),
'sessions': unique_sessions,
'projects': json_dumper(projects,
fields=["title","permalink","description","members"]
)
})
def get(self, *args, **kwargs):
organization = kwargs.get('organization', None)
response = {}
org = self.validate_request(organization)
if not org:
self.send_error(404)
else:
response['organization'] = org.to_json()
response['organization_profile'] = json_dumper(
org.get_organization_profile())
self.write(response)
def get(self, *args, **kwargs):
organization = kwargs.get('organization', None)
response = {}
org = self.validate_request(organization)
if not org:
self.send_error(404)
else:
response['organization'] = org.to_json()
response['organization_profile'] = json_dumper(
org.get_organization_profile())
self.write(response)
def get(self, *args, **kwargs):
project_id = self.get_argument('projectId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
sprint_sequence = self.get_argument('sprint', None)
response = {}
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_valid_project(project_id, permalink)
if not sprint_sequence:
sprints = list(Sprint.objects.filter(project=project))
response['sprints'] = json_dumper(sprints)
elif sprint_sequence:
try:
sprint = project.get_sprint_object(sprint_sequence)
stories = list(sprint.get_stories())
tasks = [{
story.title:
Task.objects.filter(story=story, is_active=True).count(),
'closed_tasks':
Task.objects.filter(story=story,
current_action='Closed',
is_active=True).count()
} for story in stories]
response['sprint'] = sprint.to_json()
response['stories'] = json_dumper(stories)
# updating story json with task count
for each in response['stories']:
for i in tasks:
if each['title'] in i.keys():
each.update({
'task_count': i.get(each['title']),
'closed_tasks': i['closed_tasks']
})
except ValidationError, error:
raise HTTPError(404, **{'reason': self.error_message(error)})
def post(self, *args, **kwargs):
'''
ajax call attributes:
url: /settings/project/<project>/image/<image>
type: post
data: obj ({"background-color": "ece4d9", "text-align": "left"})
'''
super(ImageSettingHandler, self).post(*args, **kwargs)
data = {}
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
title = kwargs.get('project', None)
name = kwargs.get('image', None)
project = None
image = None
post_data_keys = self.data.keys()
if not title or ('background-color' not in post_data_keys
) or ('text-align' not in post_data_keys) or not name:
data['status'] = 400
data['message'] = 'Bad Request'
else:
try:
project = Project.objects.get(title=title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Project Name.'
if project:
try:
image = Image.objects.get(name=name,
project=project)
except Image.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Image Name.'
if image:
css = {'background-color': self.data['background-color'],
'text-align': self.data['text-align']}
try:
image_setting = ImageSetting.objects.get(
image=image,
project=project)
image_setting.update(set__css=css,
set__updated_on=datetime.utcnow())
except ImageSetting.DoesNotExist:
image_setting = ImageSetting(image=image,
project=project,
css=css)
image_setting.save()
data['status'] = 200
data['settings'] = json_dumper(image_setting)
if not self._headers_written:
self.write(data)
def get(self, *args, **kwargs):
users = User.objects.only("username", "email")
unique_sessions = {}
sessions = Session.objects(user__in=users).order_by("generated_at")
# we now have to group the sessions by username,
for username, sess in groupby(sessions,
lambda x: x['user']['username']):
#print "%s has %d sessions" %(username, len(list(sess)))
unique_sessions[username] = list(sess)[-1].to_json()
projects = Project.objects.only("title", "permalink", "description",
"members")
self.write({
'users':
json_dumper(users, fields=['username', 'email']),
'sessions':
unique_sessions,
'projects':
json_dumper(
projects,
fields=["title", "permalink", "description", "members"])
})
def get(self,*args, **kwargs):
project_id = self.get_argument('projectId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
sprint_sequence = self.get_argument('sprint',None)
response = {}
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_valid_project(project_id, permalink)
if not sprint_sequence:
sprints = list(Sprint.objects.filter(project=project))
response['sprints'] = json_dumper(sprints)
elif sprint_sequence:
try:
sprint = project.get_sprint_object(sprint_sequence)
stories = list(sprint.get_stories())
tasks = [{story.title : Task.objects.filter(story=story,
is_active=True).count(),
'closed_tasks': Task.objects.filter(story=story,
current_action='Closed',
is_active=True).count()}
for story in stories]
response['sprint'] = sprint.to_json()
response['stories'] = json_dumper(stories)
# updating story json with task count
for each in response['stories']:
for i in tasks:
if each['title'] in i.keys() :
each.update({'task_count': i.get(each['title']),
'closed_tasks': i['closed_tasks']})
except ValidationError, error:
raise HTTPError(404, **{'reason': self.error_message(error)})
class UpdateHandler(BaseHandler):
"""
Project updates handler
Since an update is always tied to a project context,
this is handled within the project
"""
SUPPORTED_METHODS = ('GET', 'PUT', 'DELETE')
REQUIRED_FIELDS = {
'GET': ('project_id', ),
'PUT': (
'project_id',
'text',
),
'DELETE': ('id', )
}
def get_project(self, project_id):
try:
project = Project.objects.get(sequence=project_id,
members=self.current_user)
except Project.DoesNotExist:
project = None
return project
@authenticated
@validate_path_arg
def put(self, *args, **kwargs):
project_id = self.get_argument('project_id', None)
# Get the project object
project = self.get_project(project_id)
if not project:
self.send_error(404)
# Create a new update
update = Update()
update.created_by = self.current_user
update.project = project
update.text = self.get_argument('text', None)
try:
update.save()
except ValidationError, error:
raise HTTPError(500, **{'reason': self.error_message(error)})
response = {
'status': 200,
'message': 'Update saved successfully',
'update': json_dumper(update)
}
self.finish(json.dumps(response))
def post(self, *args, **kwargs):
'''
new data set
[{'email': email, 'role': role}, {'email': email, 'role': role}]
'''
project_id = self.get_argument('projectId', None)
project_permalink = self.get_argument('project_permalink', None)
project = None
self.invitations = []
if project_id:
project = self.get_project_object(project_id=project_id,
permalink=None)
elif project_permalink:
project = self.get_project_object(project_id=None,
permalink=project_permalink)
if not self.check_permission(project, 'can_add_member'):
raise HTTPError(403,
reason="Not permitted to add members to this project")
self.project = project
self.clean_request(project)
response = {}
response['members'] = []
for each in self.data['members']:
new_user = existing_user = None
project.members.extend(self.data['new_members'])
project.update(set__members=set(project.members))
try:
existing_user = Team.objects.get(user=each['user'],
project=project)
existing_user.update(set__role=each['role'])
except Team.DoesNotExist:
new_user = Team(user=each['user'],
project=project,
role=each['role'],
created_by=self.current_user,
updated_by=self.current_user)
new_user.save()
# exclude = ['udpated_at', 'updated_by', 'created_at', 'created_by']
if new_user:
response['members'].append(new_user.to_json())
self.send_notification(invited_user=new_user.user)
elif existing_user:
response['members'].append(existing_user.to_json())
self.send_notification(invited_user=existing_user.user)
response.update({'invitations': self.invitations})
self.write(json_dumper(response))
def get(self, *args, **kwargs):
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
response = None
project_id = self.get_argument('projectId', None)
if not project_id:
projects = Project.objects.filter(organization=org,
is_active=True)
response = json_dumper(projects)
elif project_id:
try:
project = Project.get_project_object(sequence=project_id,
organization=org)
response = project.to_json()
except ValidationError, error:
raise HTTPError(404, **{'reason': self.error_message(error)})
def get(self, *args, **kwargs):
super(ProjectHandler, self).get(*args, **kwargs)
data = {}
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
project_title = kwargs.get('project', None)
project = None
if not project_title:
data['status'] = 400
data['message'] = 'Bad Request.'
else:
try:
project = Project.objects.get(title=project_title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid project title.'
if project:
partial_image_list = []
images = Image.objects.filter(project=project)
for each in images:
partial_image_dict = {}
try:
media = self.dropbox_client.media(each.metadata['path'])
except ErrorResponse:
each.delete()
media = None
if media:
partial_image_dict['media'] = media
partial_image_dict['name'] = each.name
partial_image_dict['thumbnail'] = each.thumbnail
partial_image_list.append(partial_image_dict)
try:
project_settings = ProjectSetting.objects.get(
project=project)
except ProjectSetting.DoesNotExist:
project_settings = []
data['status'] = 200
image_thumbnails = self.getThumbnailSlug(partial_image_list)
data['images'] = image_thumbnails
data['settings'] = json_dumper(project_settings)
if not self._headers_written:
self.write(data)
def get(self, *args, **kwargs):
'''
ajax call attributes:
url: /settings/project/<project>/image/<image>
type: post
'''
super(ImageSettingHandler, self).get(*args, **kwargs)
data = {}
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
title = kwargs.get('project', None)
name = kwargs.get('image', None)
project = None
image = None
if not title or not name:
data['status'] = 400
data['message'] = 'Bad Request'
else:
try:
project = Project.objects.get(title=title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Project Name.'
if project:
try:
image = Image.objects.get(name=name,
project=project)
except Image.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Image Name.'
if image:
try:
image_setting = ImageSetting.objects.get(
image=image,
project=project)
except ImageSetting.DoesNotExist:
image_setting = []
data['status'] = 200
data['settings'] = json_dumper(image_setting)
if not self._headers_written:
self.write(data)
def get(self, *args, **kwargs):
super(InReplyToHandler, self).get(*args, **kwargs)
data = self._data
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
update_id = kwargs.get('id', None)
is_annotation = self.get_argument('is_annotation', None)
if is_annotation == 'true':
is_annotation = True
else:
is_annotation = False
annotation = None
comment = None
replied_comments = []
if not id:
data['status'] = 400
data['message'] = 'Bad Request'
else:
if is_annotation:
try:
annotation = Annotation.objects.get(pk=update_id)
except Annotation.DoesNotExist:
data['status'] = 400
data['message'] = 'Invalid Annotation'
else:
try:
comment = Comment.objects.get(pk=update_id)
except Comment.DoesNotExist:
data['status'] = 400
data['message'] = 'Invalid Annotation'
if annotation:
replied_comments = InReplyTo.objects.filter(
annotation=annotation)
elif comment:
replied_comments = InReplyTo.objects.filter(
comment=comment)
data['status'] = 200
data['replies'] = json_dumper(replied_comments)
if not self._headers_written:
self.write(data)
def get(self, *args, **kwargs):
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
story_id = self.get_argument('storyId', None)
project_id = self.get_argument('projectId', None)
response = None
if story_id and not project_id:
self.send_error(400)
if project_id and story_id:
project = self.get_project_object(sequence=project_id, org=org)
if project and story_id:
try:
story = Story.objects.get(sequence=int(story_id),
project=project)
response = story.to_json()
except Story.DoesNotExist, error:
raise HTTPError(500,
**{'reason': self.error_message(error)})
elif not story_id and project:
response = json_dumper(Story.objects.filter(project=project))
def get(self,*args, **kwargs):
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
story_id = self.get_argument('storyId', None)
project_id = self.get_argument('projectId', None)
response = None
if story_id and not project_id:
self.send_error(400)
if project_id and story_id:
project = self.get_project_object(sequence=project_id,
org=org)
if project and story_id:
try:
story = Story.objects.get(sequence=int(story_id),
project=project)
response = story.to_json()
except Story.DoesNotExist, error:
raise HTTPError(500, **{'reason':self.error_message(error)})
elif not story_id and project:
response = json_dumper(Story.objects.filter(project=project))
def get(self,*args, **kwargs):
project_id = self.get_argument('projectId', None)
task_id = self.get_argument('taskId',None)
response = {}
if project_id:
project = self.get_project_object(project_id)
if task_id:
task = self.get_task_object(project, task_id)
if not task:
raise HTTPError(404, **{'reason': 'Task not found'})
else:
response['events'] = task.next_events()
response['current'] = task._state_machine.current
response['task'] = task.to_json()
response['task_type'] = TASK_TYPES
else:
query = {
'project': project,
'is_active': True
}
# If sprint is set, get the tasks only for that sprint
sprint_number = self.get_argument('sprint', None)
sprint_metadata = {}
if sprint_number:
# Get the sprint
sprint = Sprint.objects.get(project=project,
sequence=int(sprint_number))
query['story__in'] = sprint.get_stories()
pm = ProjectMetadata.objects.filter(project=project
).exclude('project')
if pm:
sprint_metadata = pm[0].metadata[project.permalink][str(sprint_number)]
response['task'] = json_dumper(list(
Task.objects.filter(**query).exclude('project','story')
.order_by('-updated_at')
))
response['metadata'] = sprint_metadata
self.finish(json.dumps(response))
def create_invitation(self, email, role):
"""
Create invitation objects if email for
user is not found in the system
"""
invitation = Invitation(
email=email,
project=self.project,
invited_by=self.current_user,
role=role)
invitation.save()
async_email = AsycnEmail(self.request)
template = SETTINGS['template_path']+'/'+'invite_mailtemplate.html'
params={'project_name': invitation.project.title,
'project_owner': invitation.project.created_by.username,
'code': invitation.code}
async_email.generate_subject_content(subject='Welcome to Clearsoup.')
async_email.send_email(
email=invitation.email, template=template, params=params,
from_email=SETTINGS['no-reply_email'],
reply_to=SETTINGS['feedback_email'])
return json_dumper(invitation)
def get(self, *args, **kwargs):
project_id = self.get_argument('projectId', None)
task_id = self.get_argument('taskId', None)
response = {}
if project_id:
project = self.get_project_object(project_id)
if task_id:
task = self.get_task_object(project, task_id)
if not task:
raise HTTPError(404, **{'reason': 'Task not found'})
else:
response['events'] = task.next_events()
response['current'] = task._state_machine.current
response['task'] = task.to_json()
response['task_type'] = TASK_TYPES
else:
query = {'project': project, 'is_active': True}
# If sprint is set, get the tasks only for that sprint
sprint_number = self.get_argument('sprint', None)
sprint_metadata = {}
if sprint_number:
# Get the sprint
sprint = Sprint.objects.get(project=project,
sequence=int(sprint_number))
query['story__in'] = sprint.get_stories()
pm = ProjectMetadata.objects.filter(
project=project).exclude('project')
if pm:
sprint_metadata = pm[0].metadata[project.permalink][
str(sprint_number)]
response['task'] = json_dumper(
list(
Task.objects.filter(**query).exclude(
'project', 'story').order_by('-updated_at')))
response['metadata'] = sprint_metadata
self.finish(json.dumps(response))
def post(self, *args, **kwargs):
super(ProjectSettingHandler, self).post(*args, **kwargs)
data = {}
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
title = kwargs.get('project', None)
project = None
self.data = ast.literal_eval(self.data)
post_data_keys = self.data.keys()
if not title or ('background-color' not in post_data_keys
) or ('text-align' not in post_data_keys):
data['status'] = 400
data['message'] = 'Bad Request'
else:
try:
project = Project.objects.get(title=title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Project Name.'
if project:
css = {'background-color': self.data['background-color'],
'text-align': self.data['text-align']}
try:
project_settings = ProjectSetting.objects.get(
project=project)
project_settings.update(set__css=css)
except ProjectSetting.DoesNotExist:
project_settings = ProjectSetting(project=project,
css=css)
project_settings.save()
data['status'] = 200
data['settings'] = json_dumper(project_settings)
if not self._headers_written:
self.write(data)
def get(self, *args, **kwargs):
story_id = self.get_argument('storyId', None)
project_id = self.get_argument('projectId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
# is_pmo = self.get_argument('is_pmo', False)
response = {}
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_valid_project(project_id, permalink)
else:
self.send_error(400)
if project and story_id:
try:
story = Story.objects.get(sequence=int(story_id),
project=project,
is_active=True)
response['story'] = story.to_json()
response['tasks'] = json_dumper(story.get_tasks())
response['task_type'] = TASK_TYPES
except Story.DoesNotExist, error:
raise HTTPError(500, **{'reason': self.error_message(error)})
def delete(self, *args, **kwargs):
'''
{
projectId : 1,
roles: [admin, developer]
project_permalink: somesh/clearsoup
is_delete: true,
}
'''
project_id = self.get_argument('projectId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
project_permalink = self.get_argument('project_pemalink', None)
roles_to_be_deleted = self.get_argument('roles')
project = None
response = {}
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_valid_project(project_id, permalink)
elif project_permalink:
project = self.get_valid_project(project_id=None,
permalink=project_permalink)
else:
self.send_error(400)
if any([x == 'admin' for x in roles_to_be_deleted]):
self.send_error(500)
else:
roles = Role.objects.filter(project=project)
[role.delete() for role in roles if role.role in roles_to_be_deleted]
[project.roles.pop(project.roles.index(r)) for r
in roles_to_be_deleted if r in project.roles]
response['roles'] = json_dumper(list(Role.objects.filter(project=project)))
self.finish(json.dumps(response))
def get(self,*args, **kwargs):
story_id = self.get_argument('storyId', None)
project_id = self.get_argument('projectId', None)
owner = self.get_argument('owner', None)
project_name = self.get_argument('project_name', None)
# is_pmo = self.get_argument('is_pmo', False)
response = {}
if project_id:
project = self.get_valid_project(project_id)
elif owner and project_name:
permalink = owner + '/' + project_name
project = self.get_valid_project(project_id, permalink)
else:
self.send_error(400)
if project and story_id:
try:
story = Story.objects.get(sequence=int(story_id),
project=project,
is_active=True)
response['story'] = story.to_json()
response['tasks'] = json_dumper(story.get_tasks())
response['task_type'] = TASK_TYPES
except Story.DoesNotExist, error:
raise HTTPError(500, **{'reason':self.error_message(error)})
def to_json(self, fields=None, exclude=None):
return json_dumper(self, fields, exclude)
'update': json_dumper(update)
}
self.finish(json.dumps(response))
@authenticated
def get(self, *args, **kwargs):
project_id = self.get_argument('project_id', None)
# Get the project object
project = self.get_project(project_id)
if not project:
self.send_error(404)
# Retrieve updates
updates = None
try:
updates = Update.objects(project=project)\
.order_by('-id').exclude('project')[self._limit_from:self._limit_to]
except Exception, e:
print e
raise HTTPError(404)
if not updates:
updates = []
response = json_dumper(updates)
self.finish(json.dumps(response))
@authenticated
def delete(self, *args, **kwargs):
pass
self.send_error(400)
if project_id and story_id:
project = self.get_project_object(sequence=project_id, org=org)
if project and story_id:
try:
story = Story.objects.get(sequence=int(story_id),
project=project)
response = story.to_json()
except Story.DoesNotExist, error:
raise HTTPError(500,
**{'reason': self.error_message(error)})
elif not story_id and project:
response = json_dumper(Story.objects.filter(project=project))
else:
response = json_dumper(
Story.objects.filter(
is_active=True,
created_by=self.current_user).order_by('created_at'))
self.finish(json.dumps(response))
@authenticated
def post(self, *args, **kwargs):
'''TBD'''
sequence = self.get_argument('id', None)
organization = kwargs.get('organization', None)
org = self.validate_request(organization)
project = self.get_project_object(sequence=sequence, org=org)
self.write(project.to_json())
@authenticated
def delete(self, *args, **kwargs):
story_id = self.get_argument('storyId', None)
def to_json(self, fields=None, exclude=None):
return json_dumper(self, fields, exclude)
def post(self, *args, **kwargs):
'''
url : /edit-update/(?P<id>.*?)/?$
1. for general update
post_data : {
text : edited_text
is_annotation: false
}
2. for annotations:
a. if any repositioning is happening for an annotated comments
post_data : {
text : edited_text,
x: x_cordinate,
y: y_cordinate,
width: new_width,
height: new_height,
is_annotation: true
}
b, if no repositioning:
post_data : {
text : edited_text,
is_annotation: true
}
'''
data = {}
id = kwargs.get('id', None)
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
elif 'id' not in kwargs.keys() or\
'is_annotation' not in self.data.keys() or not id:
data['status'] = 400
data['message'] = 'Bad Request'
else:
is_annotation = self.data.get('is_annotation')
annotation = None
comment = None
if is_annotation:
try:
annotation = Annotation.objects.get(pk=id)
except Annotation.DoesNotExist:
data['status'] = 404
data['message'] = 'Could not edit this update.'
if annotation:
if 'x' in self.data.keys() and 'y' in self.data.keys() and\
'width' in self.data.keys() and 'height' in self.data.keys()\
and 'text' in self.data.keys():
x1 = self.data['x']
y1 = self.data['y']
width = self.data['width']
height = self.data['height']
text = self.data['text']
annotation.update(set__text=text,
set__x1=x1,
set__y1=y1,
set__width=width,
set_height=height)
elif 'x' not in self.data.keys() and 'y' not in \
self.data.keys() and 'width' not in self.data.keys() \
and 'height' not in self.data.keys() \
and 'text' in self.data.keys():
annotation.update(set__text=text)
annotation.save()
annotation.reload()
data['status'] = 200
data['update'] = json_dumper(annotation)
else:
try:
comment = Comment.objects.get(pk=id)
except Comment.DoesNotExist:
data['status'] = 404
data['message'] = 'Could not edit this update.'
if comment:
comment.update(set__text=self.data['text'])
data['status'] = 200
data['update'] = json_dumper(comment)
if not self._headers_written:
self.write(data)
def get(self, *args, **kwargs):
'''
get method which will return a published set of images based on a
valid url generated while publishing a project.
url format: '/public/project/project-name/version_value/
'''
super(PublishedHandler, self).get(*args, **kwargs)
data = {}
title = kwargs.get('project', None)
version = kwargs.get('version', None)
username = kwargs.get('username', None)
name = kwargs.get('image', None) # file name of a image.
project = None
image = name
publish_obj = None
current_screen = None
publish_user = None
if not self.user:
data = {
'state': 'Login',
'assets': {
'css': ['style.css'],
'js': ['md5.js', 'login.js']
}
}
self.render(data=data)
elif not title and not version:
data['status'] = '400'
data['message'] = 'Bad Request'
else:
try:
publish_user = User.objects.get(username=username)
except User.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid user.'
if publish_user:
try:
project = Project.objects.get(title=title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Project'
if project:
try:
project_settings = ProjectSetting.objects.get(
project=project)
except ProjectSetting.DoesNotExist:
project_settings = []
try:
publish_obj = Publish.objects.get(project=project,
version=version,
is_active=True,
created_by=publish_user)
except Publish.DoesNotExist:
latest_obj = Publish.objects.filter(
project=project,
is_active=True,
created_by=publish_user
).order_by('-version')
if latest_obj:
data['status'] = 201
data['url'] = latest_obj[0].public_url
msg = 'The work flow of the project has been'
msg = msg.join(
['', ' updated by the designer. Please'])
msg = msg.join(
['', ' click on the link below to view'])
msg = msg.join(
['', ' view the latest version.'])
data['message'] = msg
else:
data['status'] = 404
data['message'] = 'No Published entity found at this url'
if publish_obj:
if not image:
current_screen = publish_obj.starting_screen
elif name:
try:
current_screen = Image.objects.get(name=name,
project=project,
)
except Image.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid Image'
if current_screen:
hotspots = Hotspot.objects.filter(project=project,
image=current_screen)
comments = Comment.objects.filter(image=current_screen
).order_by('-updated_on')
annotations = Annotation.objects.filter(
image=current_screen
).order_by('-updated_on')
ordered_list = list(comments)
ordered_list.extend(annotations)
ordered_list = merge_sort(ordered_list)
temp_current_screen = json_dumper(current_screen)
try:
media = self.dropbox_client.media(
current_screen.metadata['path'])
except ErrorResponse:
current_screen.delete()
media = None
if media:
temp_current_screen['media'] = media
img_response = urllib2.urlopen(
temp_current_screen['media']['url'])
temp_current_screen['media']['url'] = base64.b64encode(
img_response.read())
all_images = Image.objects.filter(project=project)
data['status'] = 200
data['updates'] = json_dumper(ordered_list)
data['hotspots'] = json_dumper(hotspots)
data['project'] = json_dumper(project)
data['current_screen'] = temp_current_screen
data['images_names'] = [img.name for
img in all_images]
data['settings'] = json_dumper(
project_settings)
else:
data['status'] = 404
data['message'] = 'This image has been deleted from dropbox.'
if not self._headers_written:
is_xhr = self.request.headers.get('X-Requested-With', None )
if is_xhr and (is_xhr == 'XMLHttpRequest'):
self.write(data)
else:
self.template_file = 'publish.html'
data.update({
'assets': {
'css': ['style.css'],
'js': ['publishedView.js']
}
})
self.render(data=data)
def post(self, *args, **kwargs):
'''
Post method to create an update/annotation/reply
post url: /project/<project-name>/update/
1. For a generic update post data:
{
text: user text for the image,
image: image file name
}
ajax call = $.ajax({
url:"/project/<project-name>/update",
type:"post",
data:JSON.stringify({
text: "trying to post an update",
image: "dashboard_v1.jpg"
}),
success: function(data){console.log(data)}
});
2. for annotates:
{
text: user text for image,
image: image file name,
x: x_cordinate,
y: y_cordinate,
height: height of the annotated area in float/int,
width: width of the annotated area in float/int,
}
ajax call will be same as above.
3.for replying to a comment/annotate:
{
text: user text for the image,
in_reply_to: <id> of the main comment/annotate,
annotate: true if reply to an annotate/ false if replying to
generic post data
}
'''
super(UpdateHandler, self).post(*args, **kwargs)
data = self._data
if not self.user:
data['status'] = 403
data['message'] = 'Please login again.'
else:
title = kwargs.get('project', None)
if not title:
data['status'] = 400
data['message'] = 'Bad Request'
else:
try:
self._project = Project.objects.get(title=title)
except Project.DoesNotExist:
data['status'] = 404
data['message'] = 'Invalid project title.'
if self._project:
self.check_update_type()
if self._update_type:
if self._update_type == 'REPLY':
reply = self.create_reply()
if isinstance(reply, InReplyTo):
data['status'] = 201
data['update'] = json_dumper(reply)
else:
data = reply
elif self._update_type == 'ANNOTATE':
annotation = self.create_annotation()
if isinstance(annotation, Annotation):
data['status'] = 201
data['update'] = json_dumper(annotation)
else:
data = annotation
elif self._update_type == 'COMMENT':
comment = self.create_comment()
if isinstance(comment, Comment):
data['status'] = 201
data['update'] = json_dumper(comment)
else:
data = comment
else:
self.write(data)
if not self._headers_written:
self.write(data)
def to_json(self, fields=None, exclude=None):
"""
Return JSON interpretation of object instance.
"""
return json_dumper(self, fields, exclude)
def to_json(self, fields=None, exclude=None):
"""
Return JSON interpretation of object instance.
"""
return json_dumper(self, fields, exclude)
