android-7.0.0_r1/s

#!/usr/bin/env python
#
# Copyright 2010 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

"""Tunes DB service implementation.

This module contains all the protocol buffer and service definitions
necessary for the Tunes DB service.
"""

import base64
import sys

from google.appengine.ext import db

from protorpc import descriptor
from protorpc import message_types
from protorpc import messages
from protorpc import protobuf
from protorpc import remote

import model


class Artist(messages.Message):
  """Musician or music group responsible for music production.

  Fields:
    artist_id: Unique opaque identifier for artist.
    name: User friendly name of artist.
    album_count: Number of albums produced by artist.
  """

  artist_id = messages.StringField(1, required=True)
  name = messages.StringField(2, required=True)

  album_count = messages.IntegerField(3)


class Album(messages.Message):
  """Album produced by a musician or music group.

  Fields:
    album_id: Unique opaque identifier for artist.
    artist_id: Artist id of musician or music group that produced album.
    name: Name of album.
    released: Year when album was released.
  """

  album_id = messages.StringField(1, required=True)
  artist_id = messages.StringField(2, required=True)
  name = messages.StringField(3, required=True)
  released = messages.IntegerField(4)


class AddArtistRequest(messages.Message):
  """Request to add a new Artist to library.

  Fields:
    name: User friendly name of artist.
  """

  name = messages.StringField(1, required=True)


class AddArtistResponse(messages.Message):
  """Response sent after creation of new artist in library.

  Fields:
    artist_id: Unique opaque ID of new artist.
  """

  artist_id = messages.StringField(1, required=True)


class UpdateArtistRequest(messages.Message):
  """Update an existing artist.

  Fields:
    artist: Complete information about artist to update.
  """

  artist = messages.MessageField(Artist, 1, required=True)


class UpdateArtistResponse(messages.Message):
  """Artist update response.

  Fields:
    artist_updated: Artist was found and updated.
  """

  artist_updated = messages.BooleanField(1, required=True)


class DeleteArtistRequest(messages.Message):
  """Delete artist from library.

  Fields:
    artist_id: Unique opaque ID of artist to delete.
  """

  artist_id = messages.StringField(1, required=True)


class DeleteArtistResponse(messages.Message):
  """Artist deletion response.

  Fields:
    artist_deleted: Artist was found and deleted.
  """

  artist_deleted = messages.BooleanField(1, default=True)


class FetchArtistRequest(messages.Message):
  """Fetch an artist from the library.

  Fields:
    artist_id: Unique opaque ID of artist to fetch.
  """

  artist_id = messages.StringField(1, required=True)


class FetchArtistResponse(messages.Message):
  """Fetched artist from library.

  Fields:
    artist: Artist found in library.
  """

  artist = messages.MessageField(Artist, 1)


class SearchArtistsRequest(messages.Message):
  """Artist search request.

  Fields:
    continuation: Continuation from the response of a previous call to
      search_artists remote method.
    fetch_size: Maximum number of records to retrieve.
    name_prefix: Name prefix of artists to search.  If none provided and
      no continuation provided, search will be of all artists in library.
      If continuation is provided, name_prefix should be empty, if not, value
      is ignored.
  """

  continuation = messages.StringField(1)
  fetch_size = messages.IntegerField(2, default=10)
  name_prefix = messages.StringField(3, default=u'')


class SearchArtistsResponse(messages.Message):
  """Response from searching artists.

  Fields:
    artists: Artists found from search up to fetch_size.
    continuation: Opaque string that can be used with a new search request
      that will continue finding new artists where this response left off.
      Will not be set if there were no results from the search or fewer
      artists were returned in the response than requested, indicating the end
      of the query.
  """

  artists = messages.MessageField(Artist, 1, repeated=True)
  continuation = messages.StringField(2)


class AddAlbumRequest(messages.Message):
  """Request to add a new album to library.

  Fields:
    name: User friendly name of album.
    artist_id: Artist id of artist that produced record.
    released: Year album was released.
  """

  name = messages.StringField(1, required=True)
  artist_id = messages.StringField(2, required=True)
  released = messages.IntegerField(3)


class AddAlbumResponse(messages.Message):
  """Response sent after creation of new album in library.

  Fields:
    album_id: Unique opaque ID of new album.
  """

  album_id = messages.StringField(1, required=True)


class UpdateAlbumRequest(messages.Message):
  """Update an existing album.

  Fields:
    album: Complete information about album to update.
  """

  album = messages.MessageField(Album, 1, required=True)


class UpdateAlbumResponse(messages.Message):
  """Album update response.

  Fields:
    album_updated: Album was found and updated.
  """

  album_updated = messages.BooleanField(1, required=True)


class DeleteAlbumRequest(messages.Message):
  """Delete album from library.

  Fields:
    album_id: Unique opaque ID of album to delete.
  """

  album_id = messages.StringField(1, required=True)


class DeleteAlbumResponse(messages.Message):
  """Album deletion response.

  Fields:
    album_deleted: Album was found and deleted.
  """

  album_deleted = messages.BooleanField(1, default=True)


class FetchAlbumRequest(messages.Message):
  """Fetch an album from the library.

  Fields:
    album_id: Unique opaque ID of album to fetch.
  """

  album_id = messages.StringField(1, required=True)


class FetchAlbumResponse(messages.Message):
  """Fetched album from library.

  Fields:
    album: Album found in library.
  """

  album = messages.MessageField(Album, 1)


class SearchAlbumsRequest(messages.Message):
  """Album search request.

  Fields:
    continuation: Continuation from the response of a previous call to
      search_albums remote method.
    fetch_size: Maximum number of records to retrieve.
    name_prefix: Name prefix of albms to search.  If none provided and
      no continuation provided, search will be of all albums in library.
      If continuation is provided, name_prefix should be empty, if not, value
      is ignored.
    artist_id: Restrict search to albums of single artist.
  """

  continuation = messages.StringField(1)
  fetch_size = messages.IntegerField(2, default=10)
  name_prefix = messages.StringField(3, default=u'')
  artist_id = messages.StringField(4)


class SearchAlbumsResponse(messages.Message):
  """Response from searching artists.

  Fields:
    albums: Albums found from search up to fetch_size.
    continuation: Opaque string that can be used with a new search request
      that will continue finding new albums where this response left off.
      Will not be set if there were no results from the search or fewer
      albums were returned in the response than requested, indicating the end
      of the query.
  """

  albums = messages.MessageField(Album, 1, repeated=True)
  continuation = messages.StringField(2)


class MusicLibraryService(remote.Service):
  """Music library service."""

  __file_set = None

  def __artist_from_model(self, artist_model):
    """Helper that copies an Artist model to an Artist message.

    Args:
      artist_model: model.ArtistInfo instance to convert in to an Artist
        message.

    Returns:
      New Artist message with contents of artist_model copied in to it.
    """
    return Artist(artist_id=unicode(artist_model.key()),
                  name=artist_model.name,
                  album_count=artist_model.album_count)

  def __album_from_model(self, album_model):
    """Helper that copies an Album model to an Album message.

    Args:
      album_model: model.AlbumInfo instance to convert in to an Album
        message.

    Returns:
      New Album message with contents of album_model copied in to it.
    """
    artist_id = model.AlbumInfo.artist.get_value_for_datastore(album_model)

    return Album(album_id=unicode(album_model.key()),
                 artist_id=unicode(artist_id),
                 name=album_model.name,
                 released=album_model.released or None)

  @classmethod
  def __search_info(cls,
                    request,
                    info_class,
                    model_to_message,
                    customize_query=None):
    """Search over an Info subclass.

    Since all search request classes are very similar, it's possible to
    generalize how to do searches over them.

    Args:
      request: Search request received from client.
      info_class: The model.Info subclass to search.
      model_to_method: Function (model) -> message that transforms an instance
        of info_class in to the appropriate messages.Message subclass.
      customize_query: Function (request, query) -> None that adds additional
        filters to Datastore query based on specifics of that search message.

    Returns:
      Tuple (results, continuation):
        results: A list of messages satisfying the parameters of the request.
          None if there are no results.
        continuation: Continuation string for response if there are more
          results available.  None if there are no more results available.
    """
    # TODO(rafek): fetch_size from this request should take priority
    # over what is stored in continuation.
    if request.continuation:
      encoded_search, continuation = request.continuation.split(':', 1)
      decoded_search = base64.urlsafe_b64decode(encoded_search.encode('utf-8'))
      request = protobuf.decode_message(type(request), decoded_search)
    else:
      continuation = None
      encoded_search = unicode(base64.urlsafe_b64encode(
          protobuf.encode_message(request)))

    name_prefix = request.name_prefix

    query = info_class.search(name_prefix)
    query.order('name')
    if customize_query:
      customize_query(request, query)

    if continuation:
      # TODO(rafek): Pure query cursors are not safe for model with
      # query restrictions.  Would technically need to be encrypted.
      query.with_cursor(continuation)

    fetch_size = request.fetch_size

    model_instance = query.fetch(fetch_size)
    results = None
    continuation = None
    if model_instance:
      results = [model_to_message(i) for i in model_instance]
      if len(model_instance) == fetch_size:
        cursor = query.cursor()
        continuation = u'%s:%s' % (encoded_search, query.cursor())

    return results, continuation


  @remote.method(AddArtistRequest, AddArtistResponse)
  def add_artist(self, request):
    """Add artist to library."""
    artist_name = request.name
    def do_add():
      artist = model.ArtistInfo(name=artist_name)
      artist.put()
      return artist
    artist = db.run_in_transaction(do_add)

    return AddArtistResponse(artist_id = unicode(artist.key()))

  @remote.method(UpdateArtistRequest, UpdateArtistResponse)
  def update_artist(self, request):
    """Update artist from library."""
    def do_deletion():
      artist = model.ArtistInfo.get(request.artist.artist_id)
      if artist:
        artist.name = request.artist.name
        artist.put()
        return True
      else:
        return False
    return UpdateArtistResponse(
      artist_updated=db.run_in_transaction(do_deletion))

  @remote.method(DeleteArtistRequest, DeleteArtistResponse)
  def delete_artist(self, request):
    """Delete artist from library."""
    def do_deletion():
      artist = model.ArtistInfo.get(request.artist_id)
      if artist:
        db.delete(model.Info.all(keys_only=True).ancestor(artist))
        return True
      else:
        return False
    return DeleteArtistResponse(
      artist_deleted = db.run_in_transaction(do_deletion))

  @remote.method(FetchArtistRequest, FetchArtistResponse)
  def fetch_artist(self, request):
    """Fetch artist from library."""
    artist_model = model.ArtistInfo.get(request.artist_id)
    if isinstance(artist_model, model.ArtistInfo):
      artist = self.__artist_from_model(artist_model)
    else:
      artist = None
    return FetchArtistResponse(artist=artist)


  @remote.method(SearchArtistsRequest, SearchArtistsResponse)
  def search_artists(self, request):
    """Search library for artists."""
    results, continuation = self.__search_info(request,
                                               model.ArtistInfo,
                                               self.__artist_from_model)
    return SearchArtistsResponse(artists=results or [],
                                 continuation=continuation or None)

  @remote.method(AddAlbumRequest, AddAlbumResponse)
  def add_album(self, request):
    """Add album to library."""
    def create_album():
      if not request.artist_id:
        raise ValueError('Request does not have artist-id.')
      artist = model.ArtistInfo.get(request.artist_id)
      if not artist:
        raise ValueError('No artist found for %s.' % request.artist_id)
      artist.album_count += 1
      artist.put()

      album = model.AlbumInfo(name=request.name,
                              released=request.released,
                              artist=artist,
                              parent=artist)
      album.put()

      return album
    album = db.run_in_transaction(create_album)

    return AddAlbumResponse(album_id=unicode(album.key()))

  @remote.method(UpdateAlbumRequest, UpdateAlbumResponse)
  def update_album(self, request):
    """Update album from library."""
    def do_deletion():
      album = model.AlbumInfo.get(request.album.album_id)
      if album:
        album.name = request.album.name
        album.released = request.album.released
        album.put()
        return True
      else:
        return False
    return UpdateAlbumResponse(album_updated=db.run_in_transaction(do_deletion))

  @remote.method(DeleteAlbumRequest, DeleteAlbumResponse)
  def delete_album(self, request):
    """Delete album from library."""
    def do_deletion():
      album = model.AlbumInfo.get(request.album_id)

      artist = album.artist
      artist.album_count -= 1
      artist.put()

      if album:
        db.delete(model.Info.all(keys_only=True).ancestor(album))
        return True
      else:
        return False

    return DeleteAlbumResponse(album_deleted=db.run_in_transaction(do_deletion))

  @remote.method(FetchAlbumRequest, FetchAlbumResponse)
  def fetch_album(self, request):
    """Fetch album from library."""
    album_model = model.AlbumInfo.get(request.album_id)
    if isinstance(album_model, model.AlbumInfo):
      album = self.__album_from_model(album_model)
    else:
      album = None
    return FetchAlbumResponse(album=album)

  @remote.method(SearchAlbumsRequest, SearchAlbumsResponse)
  def search_albums(self, request):
    """Search library for albums."""
    def customize_query(request, query):
      if request.artist_id:
        query.filter('artist', db.Key(request.artist_id))

    response = SearchAlbumsResponse()
    results, continuation = self.__search_info(request,
                                               model.AlbumInfo,
                                               self.__album_from_model,
                                               customize_query)
    return SearchAlbumsResponse(albums=results or [],
                                continuation=continuation or None)