def anno_get(self, request):
"""
Exposes an API endpoint to get an anno detail by the specified id.
"""
try:
user = auth_user(self.request_state.headers)
except Exception:
user = None
if request.id is None:
raise endpoints.BadRequestException('id field is required.')
anno = Anno.get_by_id(request.id)
if anno is None:
raise endpoints.NotFoundException('No anno entity with the id "%s" exists.' % request.id)
# set anno basic properties
anno_resp_message = anno.to_response_message(user, list_message=False)
# set anno association with followups
followups = FollowUp.find_by_anno(anno)
followup_messages = [ entity.to_message(team_key=request.team_key) for entity in followups ]
anno_resp_message.followup_list = followup_messages
# set anno association with votes/flags
# if current user exists, then fetch vote/flag.
if user is not None:
anno_resp_message.is_my_vote = Vote.is_belongs_user(anno, user)
anno_resp_message.is_my_flag = Flag.is_belongs_user(anno, user)
# update last_read of UserAnnoState
UserAnnoState.update_last_read(user=user, anno=anno)
return anno_resp_message
def community_users(self, request):
user = auth_user(self.request_state.headers)
community_userroles = []
if user:
community = Community.getCommunityFromTeamKey(request.account_type)
if community and (UserRole.getCircleLevel(user, community) > 0):
community_userroles = UserRole.query().filter(ndb.AND(UserRole.community == community.key,
UserRole.circle_level > 0)
).fetch(projection=[UserRole.user])
users = []
for community_userrole in community_userroles:
current_user = community_userrole.user.get()
users.append(UserMessage(id=current_user.key.id(),
user_email=current_user.user_email,
display_name=current_user.display_name,
image_url=current_user.image_url))
# removing auth_user
[ users.remove(user_info) for user_info in users if user_info.user_email == user.user_email ]
# sorting users alphabetically
users = sorted(users, key=lambda user_info: user_info.display_name.lower())
return UserListMessage(user_list=users)
def anno_dashboard_list(self, request):
user = auth_user(self.request_state.headers)
limit = 10
if request.limit is not None:
limit = request.limit
curs = None
if request.cursor is not None:
try:
curs = Cursor(urlsafe=request.cursor)
except BadValueError:
raise endpoints.BadRequestException('Invalid cursor %s.' % request.cursor)
if request.query_type == AnnoQueryType.MY_MENTIONS:
return Anno.query_by_my_mentions_for_dashboard(limit, curs, user)
elif request.query_type == AnnoQueryType.ACTIVITY_COUNT:
return Anno.query_by_count_for_dashboard(limit, curs, user, request.query_type)
elif request.query_type == AnnoQueryType.VOTE_COUNT:
return Anno.query_by_count_for_dashboard(limit, curs, user, request.query_type)
elif request.query_type == AnnoQueryType.FLAG_COUNT:
return Anno.query_by_count_for_dashboard(limit, curs, user, request.query_type)
elif request.query_type == AnnoQueryType.ARCHIVED:
return Anno.query_by_page_for_dashboard(limit, curs, user, query_by_archived=True)
elif request.anno_id:
return Anno.query_by_anno_for_dashboard(user, request.anno_id)
else:
return Anno.query_by_page_for_dashboard(limit, curs, user)
def user_invite_accept(self, request):
if request.user_email is None:
user = auth_user(self.request_state.headers)
request.user_email = user.user_email
resp, msg = Invite.accept(request)
return ResponseMessage(success=True if resp else False, msg=msg)
def anno_insert(self, request):
"""
Exposes an API endpoint to insert an anno for the current user.
if current user doesn't exist, the user will be created first.
"""
user = auth_user(self.request_state.headers)
# checking if same anno exists
exist_anno = Anno.is_anno_exists(user, request)
if exist_anno is not None:
raise endpoints.BadRequestException("Duplicate anno(%s) already exists." % exist_anno.key.id())
entity = Anno.insert_anno(request, user)
# find all hashtags
tags = extract_tags_from_text(entity.anno_text.lower())
for tag, count in tags.iteritems():
# Write the cumulative amount per tag
Tag.add_tag_total(tag, total=count)
# index this document. strange exception here.
put_search_document(entity.generate_search_document(), SearchIndexName.ANNO)
# send push notifications
ActivityPushNotifications.send_push_notification(first_user=user, anno=entity, action_type=AnnoActionType.CREATED)
return entity.to_response_message(user)
def list_user_communities(self, request):
if request.id or request.email:
user = get_user_from_request(user_id=request.id, user_email=request.email)
else:
user = auth_user(self.request_state.headers)
user_community_list = user_community(user) if user else []
user_community_message_list = []
for userrole in user_community_list:
community = userrole.get("community").get()
if community:
community_message = CommunityMessage(id=community.key.id(), name=community.name,
description=community.description,
welcome_msg=community.welcome_msg)
user_community_message = UserCommunityMessage(community=community_message, role=userrole.get("role"))
user_community_message_list.append(user_community_message)
pending_invites_list = []
if request.include_invite and user:
pending_invites = Invite.list_by_user(user.user_email)
for pending_invite in pending_invites:
community = pending_invite.community.get().to_response_message()
pending_invites_list.append(UserInviteMessage(community=community,
invite_hash=pending_invite.invite_hash,
invite_msg=pending_invite.invite_msg))
return UserCommunityListMessage(community_list=user_community_message_list, invite_list=pending_invites_list)
def vote_insert(self, request):
"""
Exposes an API endpoint to insert a vote for the current user.
"""
user = auth_user(self.request_state.headers)
anno = Anno.get_by_id(request.anno_id)
if anno is None:
raise endpoints.NotFoundException('No anno entity with the id "%s" exists.' % request.id)
vote = Vote()
vote.anno_key = anno.key
vote.creator = user.key
if request.created is not None:
vote.created = request.created
vote.put()
anno.vote_count += 1
anno.last_update_time = datetime.datetime.now()
anno.last_activity = 'vote'
anno.last_update_type = 'create'
anno.put()
# update user anno state
UserAnnoState.insert(user=user, anno=anno, type=AnnoActionType.UPVOTED)
# update vote in search document
put_search_document(anno.generate_search_document(), SearchIndexName.ANNO)
return vote.to_message()
def anno_merge(self, request):
"""
Exposes an API endpoint to merge(update only the specified properties) an anno.
"""
user = auth_user(self.request_state.headers)
if request.id is None:
raise endpoints.BadRequestException('id field is required.')
anno = Anno.get_by_id(request.id)
if anno is None:
raise endpoints.NotFoundException('No anno entity with the id "%s" exists.' % request.id)
anno.merge_from_message(request, user)
# set last update time & activity
anno.last_update_time = datetime.datetime.now()
anno.last_activity = 'anno'
anno.put()
# update search document.
put_search_document(anno.generate_search_document(), SearchIndexName.ANNO)
# send notifications
ActivityPushNotifications.send_push_notification(first_user=user, anno=anno, action_type=AnnoActionType.EDITED)
# update last_read of UserAnnoState
from model.userannostate import UserAnnoState
UserAnnoState.update_last_read(user=user, anno=anno)
return anno.to_response_message(user)
def flag_delete(self, request):
"""
Exposes an API endpoint to delete an existing flag.
"""
user = auth_user(self.request_state.headers)
anno = None
if request.id is None and request.anno_id is None:
raise endpoints.BadRequestException('id or anno_id field is required.')
if request.id is not None:
flag = Flag.get_by_id(request.id)
if flag is None:
raise endpoints.NotFoundException('No flag entity with the id "%s" exists.' % request.id)
anno = flag.anno_key.get()
flag.key.delete()
anno.flag_count -= 1
anno.put()
elif request.anno_id is not None:
anno = Anno.get_by_id(request.anno_id)
for key in Flag.query(Flag.anno_key == anno.key, Flag.creator == user.key).iter(keys_only=True):
key.delete()
anno.flag_count -= 1
anno.put()
put_search_document(anno.generate_search_document(), SearchIndexName.ANNO)
return message_types.VoidMessage()
def flag_insert(self, request):
"""
Exposes an API endpoint to insert a flag for the current user.
"""
user = auth_user(self.request_state.headers)
anno = Anno.get_by_id(request.anno_id)
if anno is None:
raise endpoints.NotFoundException('No anno entity with the id "%s" exists.')
flag = Flag()
flag.anno_key = anno.key
flag.creator = user.key
if request.created is not None:
flag.created = request.created
flag.put()
anno.flag_count += 1
anno.last_update_time = datetime.datetime.now()
anno.last_activity = 'flag'
anno.last_update_type = 'create'
anno.put()
# update user anno state
UserAnnoState.insert(user=user, anno=anno, type=AnnoActionType.FLAGGED)
# update flag in search document
put_search_document(anno.generate_search_document(), SearchIndexName.ANNO)
return flag.to_message()
def followup_list(self, request):
"""
Exposes an API endpoint to retrieve a list of follow up.
"""
user = auth_user(self.request_state.headers)
limit = 10
if request.limit is not None:
limit = request.limit
curs = None
if request.cursor is not None:
try:
curs = Cursor(urlsafe=request.cursor)
except BadValueError:
raise endpoints.BadRequestException('Invalid cursor %s.' % request.cursor)
query = FollowUp.query().order(-FollowUp.created)
if curs is not None:
followups, next_curs, more = query.fetch_page(limit, start_cursor=curs)
else:
followups, next_curs, more = query.fetch_page(limit)
items = [entity.to_message() for entity in followups]
if more:
return FollowupListMessage(followup_list=items, cursor=next_curs.urlsafe(), has_more=more)
else:
return FollowupListMessage(followup_list=items, has_more=more)
def update_user(self, request):
action_auth_user = auth_user(self.request_state.headers)
if not (action_auth_user.user_email == request.user_email):
if not is_auth_user_admin(action_auth_user=action_auth_user):
return ResponseMessage(success=False)
user = get_user_from_request(user_id=request.user_id,
user_email=request.user_email,
team_key=request.team_key)
if user:
user.display_name = request.user_display_name or user.display_name
user.password = md5(request.user_password) if request.user_password else user.password
user.image_url = request.user_image_url or user.image_url or ""
user.put()
community = Community.getCommunityFromTeamKey(request.team_key) if request.team_key else Community.get_by_id(request.community_id)
resp = None
if user and community:
circle = 0
for circle_value, circle_name in community.circles.iteritems():
if circle_name == request.circle:
circle = int(circle_value)
resp = UserRole.edit(user, community, request.role, circle)
return ResponseMessage(success=True if resp else False)
def insert_user(self, request):
if not is_auth_user_admin(headers=self.request_state.headers):
return ResponseMessage(success=False)
action_user = auth_user(self.request_state.headers)
user = get_user_from_request(user_id=request.user_id,
user_email=request.user_email,
team_key=request.team_key)
if not user:
user = User.insert_user(request.user_email,
username=request.user_display_name,
account_type=request.team_key,
auth_source=AuthSourceType.PLUGIN,
password=md5(request.user_password),
image_url=request.user_image_url or "")
community = Community.getCommunityFromTeamKey(request.team_key) if request.team_key else Community.get_by_id(request.community_id)
role = request.role if request.role else UserRoleType.MEMBER
resp = None
if user and community:
circle = 0
for circle_value, circle_name in community.circles.iteritems():
if circle_name == request.circle:
circle = int(circle_value)
resp = UserRole.insert(user, community, role, circle)
send_added_user_email(community.name, user.display_name, "added", action_user.display_name, community.team_hash)
return ResponseMessage(success=True if resp else False)
def update_password(self, request):
current_user = get_endpoints_current_user(raise_unauthorized=False)
if current_user is not None:
raise endpoints.BadRequestException("Google OAuth User can't update password.")
user = auth_user(self.request_state.headers)
user.password = md5(request.password)
user.put()
return message_types.VoidMessage()
def update_deviceid(self, request):
user = auth_user(self.request_state.headers)
device_id = None if request.clear_device else request.device_id
device_type = None if request.clear_device else request.device_type
user.device_id = device_id
user.device_type = device_type
user.put()
return message_types.VoidMessage()
def followup_get(self, request):
"""
Exposes an API endpoint to get a followup.
"""
user = auth_user(self.request_state.headers)
if request.id is None:
raise endpoints.BadRequestException('id field is required.')
followup = FollowUp.get_by_id(request.id)
if followup is None:
raise endpoints.NotFoundException('No follow up entity with the id "%s" exists.' % request.id)
return followup.to_message()
def vote_get(self, request):
"""
Exposes an API endpoint to get a vote.
"""
user = auth_user(self.request_state.headers)
if request.id is None:
raise endpoints.BadRequestException('id field is required.')
vote = Vote.get_by_id(request.id)
if vote is None:
raise endpoints.NotFoundException('No vote entity with the id "%s" exists.' % request.id)
return vote.to_message()
def user_display_name_get(self, request):
if request.email is None:
# if no email is provided, get user by oauth.
user = auth_user(self.request_state.headers)
else:
# for not login user, get user by the provided email.
user = User.find_user_by_email(request.email)
if user is None:
return UserMessage(display_name='')
else:
return UserMessage(display_name=user.display_name)
def followup_delete(self, request):
"""
Exposes an API endpoint to delete an existing follow up.
"""
user = auth_user(self.request_state.headers)
if request.id is None:
raise endpoints.BadRequestException('id field is required.')
followup = FollowUp.get_by_id(request.id)
if followup is None:
raise endpoints.NotFoundException('No follow up entity with the id "%s" exists.' % request.id)
anno = followup.anno_key.get()
followup.key.delete()
anno.followup_count -= 1
anno.put()
return message_types.VoidMessage()
def anno_my_stuff(self, request):
"""
Exposes an API endpoint to return all my anno list.
"""
user = auth_user(self.request_state.headers)
limit = request.limit or 10
curs = None
if request.cursor is not None:
try:
curs = Cursor(urlsafe=request.cursor)
except BadValueError:
raise endpoints.BadRequestException('Invalid cursor %s.' % request.cursor)
return Anno.query_my_anno(limit, curs, user)
def followup_insert(self, request):
"""
Exposes and API endpoint to insert a follow up for the current user.
"""
user = auth_user(self.request_state.headers)
anno = Anno.get_by_id(request.anno_id)
if anno is None:
raise endpoints.NotFoundException('No anno entity with the id "%s" exists.' % request.id)
followup = FollowUp()
followup.anno_key = anno.key
followup.creator = user.key
followup.comment = request.comment
followup.tagged_users = request.tagged_users
if request.created is not None:
followup.created = request.created
followup.put()
anno.followup_count += 1
anno.last_update_time = datetime.datetime.now()
anno.last_activity = 'follwup'
anno.last_update_type = 'create'
anno.put()
# update user anno state
UserAnnoState.insert(user=user, anno=anno, type=AnnoActionType.COMMENTED)
for tagged_user_id in followup.tagged_users:
tagged_user = User.get_by_id(int(tagged_user_id))
if tagged_user:
UserAnnoState.insert(user=tagged_user, anno=anno, type=AnnoActionType.TAGGEDUSER)
# update search document
put_search_document(anno.generate_search_document(), SearchIndexName.ANNO)
put_search_document(followup.generate_search_document(), SearchIndexName.FOLLOWUP)
# find all hashtags
tags = extract_tags_from_text(followup.comment.lower())
for tag, count in tags.iteritems():
# Write the cumulative amount per tag
Tag.add_tag_total(tag, total=count)
# send notifications
ActivityPushNotifications.send_push_notification(first_user=user, anno=anno, action_type=AnnoActionType.COMMENTED,
comment=request.comment)
return followup.to_message(request.team_key)
def user_invite_list(self, request):
if request.email is None:
user = auth_user(self.request_state.headers)
user_email = user.user_email
else:
user_email = request.email
pending_invites = Invite.list_by_user(user_email)
pending_invites_list = []
for pending_invite in pending_invites:
community = pending_invite.community.get().to_response_message()
pending_invites_list.append(UserInviteMessage(community=community,
invite_hash=pending_invite.invite_hash,
invite_msg=pending_invite.invite_msg))
return UserInviteListMessage(invite_list=pending_invites_list)
def anno_delete(self, request):
"""
Exposes an API endpoint to delete an existing anno.
"""
user = auth_user(self.request_state.headers)
if request.id is None:
raise endpoints.BadRequestException('id field is required.')
anno = Anno.get_by_id(request.id)
if anno is None:
raise endpoints.NotFoundException('No anno entity with the id "%s" exists.' % request.id)
# send notifications
ActivityPushNotifications.send_push_notification(first_user=user, anno=anno, action_type=AnnoActionType.DELETED)
Anno.delete(anno)
return message_types.VoidMessage()
def anno_list(self, request):
"""
Exposes an API endpoint to retrieve a list of anno.
"""
user = auth_user(self.request_state.headers)
limit = 10
if request.limit is not None:
limit = request.limit
is_plugin = request.is_plugin or False
curs = None
if request.cursor is not None:
try:
curs = Cursor(urlsafe=request.cursor)
except BadValueError:
raise endpoints.BadRequestException('Invalid cursor %s.' % request.cursor)
select_projection = None
if request.select is not None:
select_projection = request.select.split(',')
if request.query_type == AnnoQueryType.CREATED:
return Anno.query_by_app_by_created(request.app, limit, select_projection, curs, user)
elif request.query_type == AnnoQueryType.VOTE_COUNT:
return Anno.query_by_vote_count(request.app, user)
elif request.query_type == AnnoQueryType.FLAG_COUNT:
return Anno.query_by_flag_count(request.app, user)
elif request.query_type == AnnoQueryType.ACTIVITY_COUNT:
return Anno.query_by_activity_count(request.app, user)
elif request.query_type == AnnoQueryType.LAST_ACTIVITY:
return Anno.query_by_last_activity(request.app, user)
elif request.query_type == AnnoQueryType.COUNTRY:
return Anno.query_by_country(request.app, user)
elif request.query_type == AnnoQueryType.COMMUNITY:
community = Community.get_by_id(request.community)
return Anno.query_by_community(community, limit, select_projection, curs, user)
elif request.query_type == AnnoQueryType.APP:
app = AppInfo.get(request.app)
return Anno.query_by_app(app, limit, select_projection, curs, user)
else:
return Anno.query_by_page(limit, select_projection, curs, user, is_plugin)
def anno_teamnotes_insert(self, request):
anno = Anno.get_by_id(request.id)
user = auth_user(self.request_state.headers)
if anno:
anno.team_notes = request.team_notes
UserAnnoState.tag_users(anno, anno.tagged_users, request.tagged_users)
anno.tagged_users = request.tagged_users
anno.put()
mentions = []
for tagged_user in request.tagged_users:
user_info = User.get_by_id(int(tagged_user))
is_auth_user = user_info.user_email == user.user_email
mentions.append(AnnoMentionsResponseMessage(id=user_info.key.id(),
display_name=user_info.display_name,
user_email=user_info.user_email,
image_url=user_info.image_url,
is_auth_user=is_auth_user))
return AnnoTeamNotesMetadataMessage(tags=parseTeamNotesForHashtags(request.team_notes),
mentions=mentions)
def anno_search(self, request):
"""
Exposes and API endpoint to search anno list.
"""
user = auth_user(self.request_state.headers)
if request.order_type is None:
raise endpoints.BadRequestException('order_type field is required.')
if request.order_type != 'recent' and request.order_type != 'active' and request.order_type != 'popular':
raise endpoints.BadRequestException(
'Invalid order_type field value, valid values are "recent", "active" and "popular"')
app_set = None
logging.info("only_my_apps=%s" % request.only_my_apps)
if request.only_my_apps:
app_set = set()
for anno in Anno.query_anno_by_author(user):
app_set.add(anno.app_name)
for vote in Vote.query_vote_by_author(user):
anno = Anno.get_by_id(vote.anno_key.id())
if anno is not None:
app_set.add(anno.app_name)
for flag in Flag.query_flag_by_author(user):
anno = Anno.get_by_id(flag.anno_key.id())
if anno is not None:
app_set.add(anno.app_name)
for followup in FollowUp.query_followup_by_author(user):
anno = Anno.get_by_id(followup.anno_key.id())
if anno is not None:
app_set.add(anno.app_name)
if request.order_type == 'popular':
return Anno.query_by_popular(request.limit, request.offset,
request.search_string, request.app_name, app_set, user)
elif request.order_type == 'active':
return Anno.query_by_active(request.limit, request.offset, request.search_string, request.app_name, app_set, user)
else:
return Anno.query_by_recent(request.limit, request.offset, request.search_string, request.app_name, app_set, user)
def invite_user(self, request):
creator = auth_user(self.request_state.headers)
community_name = Invite.create(request, creator)
invite_msg = request.invite_msg or ""
return CreateInviteResponseMessage(user_name=request.name, user_email=request.email,
invite_msg=invite_msg, community=community_name)
def getEngagedUsers(self, request):
user = auth_user(self.request_state.headers)
return UserListMessage(user_list=Anno.getEngagedUsers(anno_id=request.id, auth_user=user))
def list_favorite_apps(self, request):
user = get_user_from_request(user_id=request.id, user_email=request.email)
if not user:
user = auth_user(self.request_state.headers)
return UserFavoriteAppList(app_list=User.list_favorite_apps(user.key))
