def publish_user_comment_added_event(self, video_id, user_id, comment_id):
event = UserCommentedOnVideo(video_id=UUID_to_grpc(video_id),
user_id=UUID_to_grpc(user_id),
comment_id=TimeUUID_to_grpc(comment_id))
self.producer.send(USER_COMMENT_ADDED_TOPIC, event.SerializeToString())
def VideoPreview_to_SuggestedVideoPreview(video):
return SuggestedVideoPreview(
video_id=UUID_to_grpc(video.video_id),
added_date=datetime_to_Timestamp(video.added_date),
name=video.name,
preview_image_location=video.preview_image_location,
user_id=UUID_to_grpc(video.user_id))
def publish_youtube_video_added_event(self, video_id, user_id, name, description, tags, location,
preview_image_location, added_date, timestamp):
event = YouTubeVideoAdded(video_id=UUID_to_grpc(video_id), user_id=UUID_to_grpc(user_id), name=name,
description=description, tags=tags, location=location,
preview_image_location=preview_image_location,
added_date=datetime_to_Timestamp(added_date),
timestamp=datetime_to_Timestamp(timestamp))
self.producer.send(YOUTUBE_VIDEO_ADDED_TOPIC, event.SerializeToString())
def publish_user_rated_video_event(self, video_id, user_id, rating,
timestamp):
event = UserRatedVideo(
video_id=UUID_to_grpc(video_id),
user_id=UUID_to_grpc(user_id),
rating=rating,
rating_timestamp=datetime_to_Timestamp(timestamp))
serialized_event = event.SerializeToString()
#logging.debug('(' + str(type(serialized_event)) + ') ' + str(serialized_event))
self.producer.send(topic=USER_RATED_VIDEO_TOPIC,
value=serialized_event)
def GetUserRating(self, request, context):
"""Gets a user's rating of a specific video and returns 0 if the user hasn't rated the video
"""
logging.debug(">>> RatingsService:GetUserRating: ")
logging.debug(request)
result = self.ratings_service.get_user_rating(
grpc_to_UUID(request.video_id), grpc_to_UUID(request.user_id))
logging.debug(result)
response = GetUserRatingResponse(video_id=UUID_to_grpc(
result.video_id),
user_id=UUID_to_grpc(result.user_id),
rating=result.rating)
logging.debug(response)
return response
def VerifyCredentials(self, request, context):
"""Verify a user's username and password
"""
logging.debug(">>> UserManagementService:VerifyCredentials: ")
logging.debug(request)
result = self.user_management_service.verify_credentials(
request.email, request.password)
if result:
return VerifyCredentialsResponse(user_id=UUID_to_grpc(result))
else:
return VerifyCredentialsResponse()
def RelatedVideos_to_GetRelatedVideosResponse(related_videos):
response = GetRelatedVideosResponse(
video_id=UUID_to_grpc(related_videos.video_id),
paging_state=related_videos.paging_state)
if isinstance(related_videos.videos,
(list, )): # most preferred way to check if it's list
response.videos.extend(
map(VideoPreview_to_SuggestedVideoPreview, related_videos.videos))
elif related_videos.videos is not None: # single result
response.videos.extend(
[VideoPreview_to_SuggestedVideoPreview(related_videos.videos)])
return response
def SuggestedVideos_to_GetSuggestedForUserResponse(suggested_videos):
response = GetSuggestedForUserResponse(
user_id=UUID_to_grpc(suggested_videos.user_id),
paging_state=suggested_videos.paging_state)
if isinstance(suggested_videos.videos,
(list, )): # most preferred way to check if it's list
response.videos.extend(
map(VideoPreview_to_SuggestedVideoPreview,
suggested_videos.videos))
elif suggested_videos.videos is not None: # single result
response.videos.extend(
[VideoPreview_to_SuggestedVideoPreview(suggested_videos.videos)])
return response
def GetRating(self, request, context):
"""Gets the current rating stats for a video
"""
logging.debug(">>> RatingsService:GetRating: ")
logging.debug(request)
result = self.ratings_service.get_rating(grpc_to_UUID(
request.video_id))
logging.debug(result)
response = GetRatingResponse(video_id=UUID_to_grpc(result.video_id),
ratings_count=result.rating_counter,
ratings_total=result.rating_total)
logging.debug(response)
return response
def VideoPlaybackStatsModel_to_PlayStats(stats):
return PlayStats(video_id=UUID_to_grpc(stats.video_id), views=stats.views)
def CommentsByUserModel_to_GetUserComments(result):
return UserComment(comment_id=TimeUUID_to_grpc(result.comment_id),
video_id=UUID_to_grpc(result.video_id),
comment=result.comment)
def CommentsByVideoModel_to_GetVideoComments(result):
return VideoComment(comment_id=TimeUUID_to_grpc(result.comment_id),
user_id=UUID_to_grpc(result.user_id),
comment=result.comment)
def UserModel_to_UserProfile(user):
return UserProfile(user_id=UUID_to_grpc(user.user_id),
first_name=user.first_name,
last_name=user.last_name,
email=user.email)
def publish_user_created_event(self, user_id, first_name, last_name, email, timestamp):
event = UserCreated(user_id=UUID_to_grpc(user_id), first_name=first_name, last_name=last_name, email=email,
timestamp=datetime_to_Timestamp(timestamp))
self.producer.send(USER_CREATED_TOPIC, event.SerializeToString())
