Example #1
0
    def listAuthorServices(self):

        authorName = self.request.matchdict["authorname"]

        dbSession = DBSession()

        try:
            authorId, = dbSession.query(Author.id).filter_by(author_name=authorName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {"error": "unknown author %s" % authorName}

        services = []
        for service in (
            dbSession.query(Service)
            .join(AuthorServiceMap)
            .filter(Service.id == AuthorServiceMap.service_id)
            .join(Author)
            .filter(AuthorServiceMap.author_id == authorId)
            .order_by(Service.service_name)
        ):
            services.append(
                {
                    "service_id": service.id,
                    "name": service.service_name,
                    "color_icon_high_res": self.request.static_url("miapi:%s" % service.color_icon_high_res),
                    "color_icon_medium_res": self.request.static_url("miapi:%s" % service.color_icon_medium_res),
                    "color_icon_low_res": self.request.static_url("miapi:%s" % service.color_icon_low_res),
                    "mono_icon_high_res": self.request.static_url("miapi:%s" % service.mono_icon_high_res),
                    "mono_icon_medium_res": self.request.static_url("miapi:%s" % service.mono_icon_medium_res),
                    "mono_icon_low_res": self.request.static_url("miapi:%s" % service.mono_icon_low_res),
                }
            )

        return {"author_name": authorName, "services": services}
Example #2
0
    def getAuthorServiceInfo(self):

        authorName = self.request.matchdict['authorname']
        serviceName = self.request.matchdict['servicename']

        dbSession = DBSession()

        try:
            authorId, = dbSession.query(
                Author.id).filter_by(author_name=authorName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {'error': 'unknown author %s' % authorName}

        try:
            serviceId, = dbSession.query(
                Service.id).filter_by(service_name=serviceName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {'error': 'unknown service %s' % serviceName}

        try:
            asm = dbSession.query(AuthorServiceMap).filter_by(
                author_id=authorId, service_id=serviceId).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {'error': 'unknown service for author'}

        response = {
            'author':
            authorName,
            'service':
            serviceName,
            'last_update_time':
            datetime.isoformat(asm.last_update_time)
            if asm.last_update_time else None
        }

        if asm.access_token:
            response['access_token'] = asm.access_token

        if asm.access_token_secret:
            response['access_token_secret'] = asm.access_token_secret

        if asm.auxillary_data:
            response['auxillary_data'] = json.loads(asm.auxillary_data)

        return response
Example #3
0
class AuthorSearchController(object):
  
  '''
  Constructor
  '''
  def __init__(self, request):
      self.request = request
      self.dbSession = DBSession()
      

  # return all authors that match the specified search criteria
  #
  @view_config(route_name='search.author', request_method='GET', renderer='jsonp', http_cache=0)
  def searchAuthors(self):

    # get author-id for authorName
    try:
      authorList = []
      searchTerm = self.request.GET.get('name')
      if not searchTerm:
        self.request.response.status_int = 400;
        return {'error':'missing required query arg: name'}

      likeExpr = '%' + searchTerm + '%' 
      for authorName, in self.dbSession.query(Author.author_name).filter(Author.author_name.like(likeExpr)).order_by(Author.author_name):
        authorList.append(authorName) 
    except:
      self.equest.response.status_int = 404;
      return {'error':'unknown error'}

    return authorList;
class ServiceProfileController(object):
  
  '''
  Constructor
  '''
  def __init__(self, request):
    self.request = request
    self.dbSession = DBSession()
  

  # get all the service events for the author and service
  @view_config(route_name='author.services.profile', request_method='GET', renderer='jsonp', http_cache=0)
  def get_service_profile(self):
  
    authorName = self.request.matchdict['authorname']
    serviceName = self.request.matchdict['servicename']
  
    retriever = ProfileRetrievalFactory.get_retriever_for(serviceName)
    if not retriever:
      self.request.response.status_int = 404
      return {'error':'profile information is not available for service %s' % serviceName}  
      
    # get author-id for authorName
    try:
      author_id, = self.dbSession.query(Author.id).filter(Author.author_name == authorName).one()
    except:
      self.request.response.status_int = 404
      return {'error':'unknown author %s' % authorName}  
  
    # get service-id for serviceName
    try:
      serviceId, = self.dbSession.query(Service.id).filter(Service.service_name == serviceName).one()
    except:
      self.request.response.status_int = 404
      return {'error':'unknown service %s' % authorName}  
  
    try:
      mapping = self.dbSession.query(AuthorServiceMap).filter_by(service_id=serviceId,author_id=author_id).one()
    except:
      self.request.response.status_int = 404
      return {'error':'unknown service for author'}
  
    profileJSON = retriever.get_author_profile(mapping,self.dbSession,oAuthConfig.get(serviceName))
  
    self.dbSession.close()
  
    return profileJSON
Example #5
0
    def listAuthorServices(self):

        authorName = self.request.matchdict['authorname']

        dbSession = DBSession()

        try:
            authorId, = dbSession.query(
                Author.id).filter_by(author_name=authorName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {'error': 'unknown author %s' % authorName}

        services = []
        for service in dbSession.query(Service).join(AuthorServiceMap).filter(
                Service.id == AuthorServiceMap.service_id).join(Author).filter(
                    AuthorServiceMap.author_id == authorId).order_by(
                        Service.service_name):
            services.append({
                'service_id':
                service.id,
                'name':
                service.service_name,
                'color_icon_high_res':
                self.request.static_url(
                    'miapi:%s' % service.color_icon_high_res),
                'color_icon_medium_res':
                self.request.static_url(
                    'miapi:%s' % service.color_icon_medium_res),
                'color_icon_low_res':
                self.request.static_url(
                    'miapi:%s' % service.color_icon_low_res),
                'mono_icon_high_res':
                self.request.static_url(
                    'miapi:%s' % service.mono_icon_high_res),
                'mono_icon_medium_res':
                self.request.static_url(
                    'miapi:%s' % service.mono_icon_medium_res),
                'mono_icon_low_res':
                self.request.static_url('miapi:%s' % service.mono_icon_low_res)
            })

        return {'author_name': authorName, 'services': services}
Example #6
0
    def getAuthorServiceInfo(self):

        authorName = self.request.matchdict["authorname"]
        serviceName = self.request.matchdict["servicename"]

        dbSession = DBSession()

        try:
            authorId, = dbSession.query(Author.id).filter_by(author_name=authorName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {"error": "unknown author %s" % authorName}

        try:
            serviceId, = dbSession.query(Service.id).filter_by(service_name=serviceName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {"error": "unknown service %s" % serviceName}

        try:
            asm = dbSession.query(AuthorServiceMap).filter_by(author_id=authorId, service_id=serviceId).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {"error": "unknown service for author"}

        response = {
            "author": authorName,
            "service": serviceName,
            "last_update_time": datetime.isoformat(asm.last_update_time) if asm.last_update_time else None,
        }

        if asm.access_token:
            response["access_token"] = asm.access_token

        if asm.access_token_secret:
            response["access_token_secret"] = asm.access_token_secret

        if asm.auxillary_data:
            response["auxillary_data"] = json.loads(asm.auxillary_data)

        return response
Example #7
0
    def putAuthorService(self):

        authorName = self.request.matchdict['authorname']
        serviceName = self.request.matchdict['servicename']

        credentials = self.request.json_body
        accessToken = credentials.get('access_token')
        accessTokenSecret = credentials.get('access_token_secret')

        # check for auxillary data and convert to a string if it exists
        auxillaryData = credentials.get('auxillary_data')
        if auxillaryData:
            auxillaryData = json.dumps(auxillaryData)

        dbSession = DBSession()

        try:
            authorId, = dbSession.query(
                Author.id).filter_by(author_name=authorName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {'error': 'unknown author %s' % authorName}

        try:
            serviceId, = dbSession.query(
                Service.id).filter_by(service_name=serviceName).one()
        except NoResultFound:
            self.request.response.status_int = 404
            return {'error': 'unknown service %s' % serviceName}

        authorServiceMap = AuthorServiceMap(authorId, serviceId, accessToken,
                                            accessTokenSecret, auxillaryData)

        try:
            dbSession.add(authorServiceMap)
            dbSession.commit()
            log.info("created author/service link: %s -> %s" % (authorName,
                                                                serviceName))

        except IntegrityError, e:
            dbSession.rollback()
            self.request.response.status_int = 409
            return {'error': e.message}
Example #8
0
class FeatureController(object):
  '''
  classdocs
  '''

  def __init__(self,request):
    '''
    Constructor
    '''
    self.request = request
    self.dbSession = DBSession()


  @view_config(route_name='features', request_method='GET', renderer='jsonp', http_cache=0)
  def listFeatures(self):

    featureList = []
    for feature in self.dbSession.query(Feature).order_by(Feature.name):
      featureList.append(feature.toJSONObject())
  
    return {'features':featureList}


  @view_config(route_name='feature.CRUD', request_method='PUT', renderer='jsonp', http_cache=0)
  def addFeature(self):

    featureName = self.request.matchdict['featurename']

    feature = Feature(featureName)
  
    try:
      self.dbSession.add(feature)
      self.dbSession.flush()
      self.dbSession.commit()
      log.info("create feature: %(featurename)s" % {'featurename':featureName})
  
    except IntegrityError, e:
      self.dbSession.rollback()
      self.request.response.status_int = 409
      return {'error':e.message}
  
    return {'service': feature.toJSONObject()}
Example #9
0
 def __init__(self, request):
     self.request = request
     self.dbSession = DBSession()
Example #10
0
class ServicesController(object):

  '''
  Constructor
  '''
  def __init__(self, request):
    self.request = request
    self.dbSession = DBSession()

  # GET /v1/accounts
  #
  # return info on all services
  @view_config(route_name='services', request_method='GET', renderer='jsonp', permission='admin', http_cache=0)
  def list_accounts(self):
  
    serviceList = []
    for service in self.dbSession.query(Service).order_by(Service.service_name):
      serviceList.append({'service_id':service.id,
                          'name':service.service_name,
                          'color_icon_high_res':self.request.static_url('miapi:%s' % service.color_icon_high_res),
                          'color_icon_medium_res':self.request.static_url('miapi:%s' % service.color_icon_medium_res),
                          'color_icon_low_res':self.request.static_url('miapi:%s' % service.color_icon_low_res),
                          'mono_icon_high_res':self.request.static_url('miapi:%s' % service.mono_icon_high_res),
                          'mono_icon_medium_res':self.request.static_url('miapi:%s' % service.mono_icon_medium_res),
                          'mono_icon_low_res':self.request.static_url('miapi:%s' % service.mono_icon_low_res)})
  
    return {'services':serviceList}


  # retrieve information about a service
  @view_config(route_name='services.CRUD', request_method='GET', renderer='jsonp', permission='admin', http_cache=0)
  def get(self):
    
    serviceName = self.request.matchdict['servicename']
    
    service = self.dbSession.query(Service).filter_by(service_name=serviceName).one()
  
    return {'service_id':service.id,
            'name':service.service_name,
            'color_icon_high_res':self.request.static_url('miapi:%s' % service.color_icon_high_res),
            'color_icon_medium_res':self.request.static_url('miapi:%s' % service.color_icon_medium_res),
            'color_icon_low_res':self.request.static_url('miapi:%s' % service.color_icon_low_res),
            'mono_icon_high_res':self.request.static_url('miapi:%s' % service.mono_icon_high_res),
            'mono_icon_medium_res':self.request.static_url('miapi:%s' % service.mono_icon_medium_res),
            'mono_icon_low_res':self.request.static_url('miapi:%s' % service.mono_icon_low_res)}
  
  # add a new service
  @view_config(route_name='services.CRUD', request_method='PUT', renderer='jsonp', permission='admin', http_cache=0)
  def put(self):
  
    serviceName = self.request.matchdict['servicename']
  
    images = self.request.json_body
  
    colorHighRes = images.get('color_icon_high_res',None)
    colorMedRes = images.get('color_icon_medium_res',None)
    colorLowRes = images.get('color_icon_low_res',None)
    monoHighRes = images.get('mono_icon_high_res',None)
    monoMedRes = images.get('mono_icon_medium_res',None)
    monoLowRes = images.get('mono_icon_low_res',None)
  
    service = Service(serviceName,colorHighRes,colorMedRes,colorLowRes,monoHighRes,monoMedRes,monoLowRes)
  
    try:
      self.dbSession.add(service)
      self.dbSession.commit()
      log.info("create service: %(servicename)s" % {'servicename':serviceName})
  
    except IntegrityError, e:
      self.dbSession.rollback()
      self.request.response.status_int = 409
      return {'error':e.message}
  
    service = self.dbSession.query(Service).filter_by(service_name=serviceName).first()
  
    return {'service': service.toJSONObject()}
Example #11
0
def session_remove_callback(request):
  DBSession.remove()
Example #12
0
class AuthorController(object):

  '''
  Constructor
  '''
  def __init__(self, request):
    self.request = request
    self.dbSession = DBSession()


  ##
  ## authors
  ##
  
  # GET /v1/authors
  #
  # get list of all authors
  @view_config(route_name='authors', request_method='GET', renderer='jsonp', http_cache=0)
  def authorsList(self):
    
    authorlist = []
    for author in self.dbSession.query(Author).order_by(Author.author_name):
      authorJSON = author.toJSONObject()
      authorlist.append(authorJSON)
    
    return {'authors':authorlist}


  # GET /v1/authors/{authorname}
  #
  # get information about a single author
  @view_config(route_name='author.CRUD', request_method='GET', renderer='jsonp', http_cache=0)
  def authorGet(self):
  
    authorName = self.request.matchdict['authorname']
  
    try:
      author = self.dbSession.query(Author).filter_by(author_name=authorName).one()
    except NoResultFound:
      self.request.response.status_int = 404
      return {'error':'unknown author %s' % authorName}
  
    authorJSONObj = author.toJSONObject()
    authorJSONObj['features'] = getAuthorFeatures(self.dbSession,author.id)

    return {'author': authorJSONObj}


  ##
  ## Create/update/delete author
  ##
  
  # PUT /v1/authors/{authorname}
  #
  # create a new author or update an existing author
  @view_config(route_name='author.CRUD', request_method='PUT', renderer='jsonp', http_cache=0)
  def authorPut(self):
  
    authorname = self.request.matchdict['authorname']
  
    authorInfo = self.request.json_body
    
    password = authorInfo.get('password')
    if password == None:
      self.request.response.status_int = 400
      return {'error':'Missing required property: password'}
    
    fullname = authorInfo.get('fullname')
    if fullname == None:
      self.request.response.status_int = 400
      return {'error':'Missing required property: fullname'}
    
    email = authorInfo.get('email')
    if email == None:
      self.request.response.status_int = 400
      return {'error':'Missing required property: email'}
    
    template = authorInfo.get('template')
    
    try:
    
      author = Author(authorname,email,fullname,password,template)
      self.dbSession.add(author)
      self.dbSession.flush() # flush so we can get the id
      
      ''' ??? this might only be temporary ???
          Create a default group (follow) and add the author to that group
          so that author is following themselves.
      '''
      
      authorGroup = AuthorGroup(author.id,DEFAULT_AUTHOR_GROUP)
      self.dbSession.add(authorGroup)
      self.dbSession.flush()
   
      mapping = AuthorGroupMap(authorGroup.id,author.id)
      self.dbSession.add(mapping)
      self.dbSession.flush()
  
      ''' Add the new author to the authors access group '''
      groupId, = self.dbSession.query(AccessGroup.id).filter_by(group_name=ACCESS_GROUP_AUTHORS).one()
      authorAccessGroupMap = AuthorAccessGroupMap(author.id,groupId)
      self.dbSession.add(authorAccessGroupMap)
      self.dbSession.flush()
  
      authorJSON = author.toJSONObject()
    
      self.dbSession.commit()
  
      log.info("create author %s and added to group %s" % (authorname, ACCESS_GROUP_AUTHORS))
  
    except IntegrityError, e:
      self.dbSession.rollback()
      log.error(e.message)
      self.request.response.status_int = 409
      return {'error':e.message}
  
    except NoResultFound, e:
      self.dbSession.rollback()
      log.error(e.message)
      self.request.response.status_int = 409
      return {'error': e.message}
Example #13
0
class AuthorGroupController(object):
  
  '''
  Constructor
  '''
  def __init__(self, request):
    self.request = request
    self.dbSession = DBSession()


  # GET /v1/authors/{authorname}/groups
  #
  # return all authors that match the specified search criteria
  #
  @view_config(route_name='author.groups', request_method='GET', renderer='jsonp', http_cache=0)
  def listGroupsHndlr(self):

    authorName = self.request.matchdict['authorname']

    try:
      authorId, = self.dbSession.query(Author.id).filter(Author.author_name==authorName).one()
    except NoResultFound:
      self.request.response.status_int = 404
      return {'error':'unknown author %s' % authorName}

    groupList = []
    for group in self.dbSession.query(AuthorGroup).filter(AuthorGroup.author_id==authorId).order_by(AuthorGroup.group_name):
      groupList.append(group.toJSONObject())

    return {'author_id': authorId, 'groups': groupList}


  # GET /v1/authors/{authorname}/groups/{groupname}
  #
  @view_config(route_name='author.groups.CRUD', request_method='GET', renderer='jsonp', http_cache=0)
  def getGroupDetailHndlr(self):
    
    authorName = self.request.matchdict['authorname']
    groupName = self.request.matchdict['groupname']
  
    try:
      authorId, = self.dbSession.query(Author.id).filter_by(author_name=authorName).one()
    except NoResultFound:
      self.request.response.status_int = 404
      return {'error':'unknown author %s' % authorName}

    try:
      authorGroup = self.dbSession.query(AuthorGroup).filter(and_(AuthorGroup.author_id==authorId,AuthorGroup.group_name==groupName)).one()
    except NoResultFound:
      self.request.response.status_int = 404
      return {'error':'unknown group %s for author %s' % (groupName,authorName)}

    return authorGroup.toJSONObject()



  # PUT /v1/authors/{authorname}/groups/{groupname}
  #
  @view_config(route_name='author.groups.CRUD', request_method='PUT', renderer='jsonp', http_cache=0)
  def addUpdateGroupHndlr(self):
    
    authorName = self.request.matchdict['authorname']
    groupName = self.request.matchdict['groupname']

    try:
      authorId, = self.dbSession.query(Author.id).filter_by(author_name=authorName).one()
    except NoResultFound:
      self.request.response.status_int = 404
      return {'error':'unknown author %s' % authorName}

    authorGroup = AuthorGroup(authorId,groupName)
    jsonObject = None

    try:
      self.dbSession.add(authorGroup)
      self.dbSession.flush()
      jsonObject = authorGroup.toJSONObject()
      self.dbSession.commit()
      log.info("created author_group: %s" % authorGroup)
  
    except IntegrityError, e:
      self.dbSession.rollback()
      self.request.response.status_int = 409
      return {'error':e.message}
    
    return jsonObject
Example #14
0
 def __init__(self,request):
   '''
   Constructor
   '''
   self.request = request
   self.dbSession = DBSession()